希望打印的新的列表能够覆盖原来的列表显示，只用看create_environment函数

猪猪虾

‘！！！！！！！！！！！
程序虽然长，但是都不用看，看create_environment（第一个定义的函数即可，只有这里是显示用的）
我想打印的列表就是env_list ，每次新生成的列表，覆盖掉原列表显示


’

1. import numpy as np
   
2. import pandas as pd
   
3. import time
   
4. 
   
5. def create_environment(state_x,state_y,episode,step_counter,table):
   
6.     '''
   
7.     就是创建游戏的简单画面，定义游戏的移动等
   
8.     '''
   
9.     env_list = [['#', '#', '#', '#'] ,
   
10.                 ['#', '&', '&', '#'] ,
    
11.                 ['#', '&', '@', '#'] ,
    
12.                 ['#', '#', '#', '#'] ]
    
13.     if state_x == 1000:
    
14.         interraction = 'episode %d: total step_step_move: %d'%(episode + 1,step_counter)
    
15.         print('\r{}'.format(interraction),end = '')
    
16.         time.sleep(2)
    
17.         print('\r                 ',end = '')
    
18.     else:
    
19.         env_list[state_x][state_y] = 'o'
    
20.         #interraction = ''.join(env_list)
    
21.         #print('\r{}'.format(interraction),end = '')
    
22.         print("***************new way******************")
    
23.         print("\n")
    
24.         for i in range(4):
    
25.             print(env_list[i])
    
26.             print("\n")
    
27.         time.sleep(Fresh_time)
    
28. 
    
29. def get_evn_feedback(state_x,state_y,A):
    
30.     '''
    
31.     就是看环境会给我多少reward以及下一步的状态是什么
    
32.     '''
    
33.     if A == 'right':
    
34.         #判断有没有超出边界
    
35.         if state_x >= N_state_x or state_x < 0 or \
    
36.            state_y >= N_state_y or state_y < 0:
    
37.            R = -1
    
38.            if state_x >= N_state_x:
    
39.                state_x  =0
    
40.            if state_x < 0:
    
41.                state_x  = N_state_x-1
    
42.            if state_y >= N_state_y:
    
43.                state_y  = 0
    
44.            if state_y < 0:
    
45.                state_y  = N_state_y-1
    
46.         
    
47.         #踩到陷阱
    
48.         elif (state_x,state_y) in [(1,1),(1,2),(2,1)]:
    
49.             state_x = state_x
    
50.             state_y += 1
    
51.             R = -1
    
52.         
    
53.         #终点
    
54.         elif (state_x,state_y)  == (2,2):
    
55.             state_x = 1000
    
56.             state_y = 1000
    
57.             R = 1
    
58.         
    
59.         #其他情况不给奖励
    
60.         else:
    
61.             R = 0
    
62.             if state_y - 1 <0:
    
63.                 state_y = N_state_y-1
    
64.             else:
    
65.                 state_y -= 1
    
66.             state_x = state_x
    
67.             
    
68.    
    
69.     elif A == 'left':
    
70.         #判断有没有超出边界
    
71.         if state_x >= N_state_x or state_x < 0 or \
    
72.            state_y >= N_state_y or state_y < 0:
    
73.            R = -1
    
74.            if state_x >= N_state_x:
    
75.                state_x  =0
    
76.            if state_x < 0:
    
77.                state_x  = N_state_x-1
    
78.            if state_y >= N_state_y:
    
79.                state_y  =0
    
80.            if state_y < 0:
    
81.                state_y  = N_state_y-1
    
82.         
    
83.         #踩到陷阱
    
84.         elif (state_x,state_y) in [(1,1),(1,2),(2,1)]:
    
85.             state_x = state_x
    
86.             state_y -= 1
    
87.             R = -1
    
88.         
    
89.         #终点
    
90.         elif (state_x,state_y)  == (2,2):
    
91.             state_x = 1000
    
92.             state_y = 1000
    
93.             R = 1
    
94.         
    
95.         #其他情况不给奖励
    
96.         else:
    
97.             R = 0
    
98.             state_x = state_x
    
99.             if state_y +1 >= N_state_y:
    
100.                 state_y = 0
     
101.             else:
     
102.                 state_y += 1
     
103.             
     
104.         
     
105.     elif A == 'up':
     
106.         #判断有没有超出边界
     
107.         if state_x >= N_state_x or state_x < 0 or \
     
108.            state_y >= N_state_y or state_y < 0:
     
109.            R = -1
     
110.            if state_x >= N_state_x:
     
111.                state_x  =0
     
112.            if state_x < 0:
     
113.                state_x  = N_state_x -1
     
114.            if state_y >= N_state_y:
     
115.                state_y  =0
     
116.            if state_y < 0:
     
117.                state_y  = N_state_y -1
     
118.         
     
119.         #踩到陷阱
     
120.         elif (state_x,state_y) in [(1,1),(1,2),(2,1)]:
     
121.             state_x -= 1
     
122.             state_y = state_y
     
123.             R = -1
     
124.         
     
125.         #终点
     
126.         elif (state_x,state_y)  == (2,2):
     
127.             state_x = 1000
     
128.             state_y = 1000
     
129.             R = 1
     
130.         
     
131.         #其他情况不给奖励
     
132.         else:
     
133.             R = 0
     
134.             if state_x - 1 < 0:
     
135.                 state_x = N_state_x - 1
     
136.             else:
     
137.                 state_x -= 1            
     
138.             state_y = state_y
     
139.             
     
140.             
     
141.             
     
142.             
     
143.     else:
     
144.             #判断有没有超出边界
     
145.             if state_x >= N_state_x or state_x < 0 or \
     
146.                state_y >= N_state_y or state_y < 0:
     
147.                R = -1
     
148.                if state_x >= N_state_x:
     
149.                    state_x  =0
     
150.                if state_x < 0:
     
151.                    state_x  = N_state_x -1
     
152.                if state_y >= N_state_y:
     
153.                    state_y  =0
     
154.                if state_y < 0:
     
155.                    state_y  = N_state_y -1
     
156.             
     
157.             #踩到陷阱
     
158.             elif (state_x,state_y) in [(1,1),(1,2),(2,1)]:
     
159.                 state_x += 1
     
160.                 state_y = state_y
     
161.                 R = -1
     
162.             
     
163.             #终点
     
164.             elif (state_x,state_y)  == (2,2):
     
165.                 state_x = 1000
     
166.                 state_y = 1000
     
167.                 R = 1
     
168.             #其他情况不给奖励
     
169.             else:
     
170.                 R = 0
     
171.                 if state_x + 1 >= N_state_x:
     
172.                     state_x = 0
     
173.                 else:
     
174.                     state_x += 1
     
175.                 state_y = state_y
     
176.                
     
177.     return state_x,state_y,R
     
178. 
     
179. def build_q_table(N_state_x,N_state_y):
     
180.     table = np.zeros((N_state_x,N_state_y)) #表格的值都初始化为0            
     
181.     return table
     
182. 
     
183. #print(build_q_table(N_state,Action))
     
184. 
     
185. def choose_action(state_x,state_y,q_table):
     
186.     '''
     
187.     state = (N_state_x,N_state_y)
     
188.     下一步动作的选取要根据当前的状态以及已有的q_table来进行选择
     
189.     选择的时候分为两种情况：
     
190.     1.在90%的情况下，根据当前的状态以及已有的q_table来选择最优的action
     
191.     2.10%的情况下，随机选择一个action
     
192.     '''
     
193. 
     
194.     score_of_4_dir,score_of_4_direction = get_neibor_q(state_x,state_y,q_table)
     
195.    
     
196.     #>0.9,也就是产生的随机数是在0.9~1之间，10%的情况下，随机选择下部一的动作
     
197.     #全部为0的情况也随机选取下一步的状态
     
198.     sign_all_0 = True
     
199.     #判断上下左右四个分数是不是全部为0
     
200.     for i in range(len(score_of_4_dir)):
     
201.         if score_of_4_dir[i] != 0 and score_of_4_dir[i] != -100:
     
202.            sign_all_0= False
     
203.            break
     
204.            
     
205.     if np.random.uniform() > Greedy_plicy or sign_all_0 == True :
     
206.         #socre = -100的位置表示已经超出了游戏边界，这个方向不能走，三级选择的方向里面需要排除掉这些，
     
207.         #再进行随机选择
     
208.         action_choice =  Action.copy()
     
209.         for i in range(4):  #四个方向
     
210.             if score_of_4_dir[i] == -100:
     
211.                 action_choice[i] = 'prohibit'
     
212.             
     
213.         #一直随机挑选，不能选择标记为none的方向
     
214.         action_name = ''
     
215.         while action_name == 'prohibit' or action_name == '':
     
216.             action_name = np.random.choice(action_choice)
     
217.                                 
     
218.     else:
     
219.         #标记为none的地方对应的q表值为-100，不可能是最大值
     
220.         
     
221.         action_name = Action[score_of_4_dir.index(max(score_of_4_dir))]  #返回state_of_action里面较大值的索引   
     
222.     return action_name
     
223. 
     
224. 
     
225. 
     
226. 
     
227. 
     
228. def get_neibor_q(state_x,state_y,q_table):
     
229.     '''
     
230.     获取当前状态的上下左右四个状态的q值以及对应的坐标
     
231.     '''
     
232.     #当前的点不一定能向四个方向前进，可能到边上了
     
233.     #分数在列表里面的存储顺序默认为 上下左右
     
234.     position_of_4_direction = [[state_x-1, state_y],\
     
235.                                [state_x+1, state_y],\
     
236.                                [state_x, state_y-1],\
     
237.                                [state_x, state_y+1]]
     
238.     score_of_4_dir = []
     
239.     for i in range(len(position_of_4_direction)):
     
240. 
     
241.         if  position_of_4_direction[i][0] < 0 or position_of_4_direction[i][0] >= N_state_x \
     
242.          or position_of_4_direction[i][1] < 0 or position_of_4_direction[i][1] >= N_state_y:
     
243.             position_of_4_direction[i][0]  = -100
     
244.             position_of_4_direction[i][1]  = -100  #设置成这个值，表示这个方向不能走
     
245.             score_of_4_dir.append(-100)
     
246.         else:
     
247. #            print("position_of_4_direction[{}][0]={}  ".format(i,position_of_4_direction[i][0]))
     
248. #            print("\n")
     
249. #            print("position_of_4_direction[{}][0]={}".format(i,position_of_4_direction[i][1]))
     
250. #            print("\n")
     
251.             score_of_4_dir.append(q_table[position_of_4_direction[i][0],position_of_4_direction[i][1]])
     
252.     return score_of_4_dir,position_of_4_direction
     
253.    
     
254.    
     
255. def reforcement_learning():
     
256.     table = build_q_table(N_state_x,N_state_y)
     
257.     for episode in range(max_episodes):
     
258.          state_x,state_y = 0,0
     
259.       
     
260.          step_counter =0
     
261.          create_environment(state_x,state_y,episode,step_counter,table)
     
262.          
     
263.          while state_x != 1000:
     
264.              A = choose_action(state_x,state_y,table)
     
265.              state_x_,state_y_,R = get_evn_feedback(state_x,state_y,A)
     
266.              q_predict = table[state_x,state_y]
     
267.             
     
268.              if state_x_ != 1000 :
     
269.                  score_of_4_dir,position_of_4_direction = get_neibor_q(state_x,state_y,table)
     
270.                  position_of_4_direction = get_neibor_q(state_x,state_y,table)
     
271.                  reality = R +  discount_factor * max(score_of_4_dir)
     
272.              else:
     
273.                  reality= R  #discount_factor * max(table.iloc[S_,:])不存在了，已经终结没有下一个状态了
     
274.                  state_x,state_y  = 1000,1000
     
275.             
     
276.              table[state_x,state_y] = table[state_x,state_y] + Learning_rate * (reality - q_predict)
     
277.              state_x,state_y = state_x_,state_y_
     
278.             
     
279.              create_environment(state_x,state_y,episode,step_counter+1,table)
     
280.              step_counter += 1
     
281.     return table
     
282. 
     
283. 
     
284. 
     
285. if __name__== "__main__":
     
286.     N_state_x = 4  #状态的种类
     
287.     N_state_y = 4
     
288.     Action = ['up','down','left','right']
     
289.     Greedy_plicy = 0.9   #多少比例择优选择action，其余比例下随机选择action
     
290.     Learning_rate = 0.1   #学习率
     
291.     discount_factor = 0.9  #未来奖励的衰减值
     
292.     max_episodes = 50   #只玩13回合就结束
     
293.     Fresh_time = 0.3    #0.3秒显示走一步
     
294.     np.random.seed(2)  
     
295. 
     
296.     q_table = reforcement_learning()  
     
297.     print(q_table)
     
298.         
     
299.             
     
300.    
     
301.    
     
302.    
     
303.    
     
304.    
     
305.    

复制代码

tryhi

不错，支持一下