मैं क्यू सीखने और दीप तंत्रिका नेटवर्क के साथ अपने आप को परिचित करने की कोशिश (कैसे एक दीप-क्यू-नेट का मूल्यांकन करने के लिए), वर्तमान में Playing Atari with Deep Reinforcement Learning लागू करने के लिए प्रयास करें।क्यों मेरी गहरी Q नेटवर्क एक सरल Gridworld (Tensorflow) गुरु नहीं करता है?
मेरी कार्यान्वयन का परीक्षण और इसके साथ चारों ओर खेलने के लिए, मैं tought मैं एक साधारण gridworld प्रयास करें। जहां मेरे पास एन एक्स एन ग्रिड है और शीर्ष बाएं कोने में शुरू होता है और नीचे दाईं ओर खत्म होता है। संभावित कार्य हैं: बाएं, ऊपर, दाएं, नीचे।
हालांकि मेरी कार्यान्वयन बहुत this के समान बन गया है (उम्मीद है कि इसकी एक अच्छा एक) यह dosn't कुछ भी जानने के लिए लग रहे हैं। कुल चरणों इसे पूरा करने की जरूरत है को देखते हुए (मुझे लगता है कि औसत 10x10 की एक gridsize के साथ 500 aroung होगा, लेकिन वहाँ भी बहुत कम है और उच्च मान), यह मेरे लिए कुछ और की तुलना में अधिक यादृच्छिक तेजी।
मैंने इसे संकल्पक परतों के साथ और बिना कोशिश की और सभी मानकों के साथ खेला लेकिन ईमानदार होने के लिए, मुझे नहीं पता कि मेरे कार्यान्वयन के साथ कुछ गलत है या इसे लंबे समय तक प्रशिक्षित करने की आवश्यकता है (मैंने इसे काफी समय) या क्या कभी।
तो इस मामले में समस्या क्या है: लेकिन कम से कम यह नुकसान मूल्य एक प्रशिक्षण सत्र की साजिश कवरेज़ की तेजी, यहाँ?
लेकिन यह और भी महत्वपूर्ण बात यह है कि मैं इस डीप-क्यू-नेट को "डीबग" कैसे कर सकता हूं, पर्यवेक्षित प्रशिक्षण में प्रशिक्षण, परीक्षण और सत्यापन सेट होते हैं और उदाहरण के लिए परिशुद्धता और याद करते हैं कि उनका मूल्यांकन करना संभव है। डीप-क्यू-नेट के साथ असुरक्षित शिक्षा के लिए मेरे पास कौन से विकल्प हैं, ताकि अगली बार मैं इसे स्वयं ठीक कर सकूं?
ACTIONS = 5
# Inputs
x = tf.placeholder('float', shape=[None, 10, 10, 4])
y = tf.placeholder('float', shape=[None])
a = tf.placeholder('float', shape=[None, ACTIONS])
# Layer 1 Conv1 - input
with tf.name_scope('Layer1'):
W_conv1 = weight_variable([8,8,4,8])
b_conv1 = bias_variable([8])
h_conv1 = tf.nn.relu(conv2d(x, W_conv1, 5)+b_conv1)
# Layer 2 Conv2 - hidden1
with tf.name_scope('Layer2'):
W_conv2 = weight_variable([2,2,8,8])
b_conv2 = bias_variable([8])
h_conv2 = tf.nn.relu(conv2d(h_conv1, W_conv2, 1)+b_conv2)
h_conv2_max_pool = max_pool_2x2(h_conv2)
# Layer 3 fc1 - hidden 2
with tf.name_scope('Layer3'):
W_fc1 = weight_variable([8, 32])
b_fc1 = bias_variable([32])
h_conv2_flat = tf.reshape(h_conv2_max_pool, [-1, 8])
h_fc1 = tf.nn.relu(tf.matmul(h_conv2_flat, W_fc1)+b_fc1)
# Layer 4 fc2 - readout
with tf.name_scope('Layer4'):
W_fc2 = weight_variable([32, ACTIONS])
b_fc2 = bias_variable([ACTIONS])
readout = tf.matmul(h_fc1, W_fc2)+ b_fc2
# Training
with tf.name_scope('training'):
readout_action = tf.reduce_sum(tf.mul(readout, a), reduction_indices=1)
loss = tf.reduce_mean(tf.square(y - readout_action))
train = tf.train.AdamOptimizer(1e-6).minimize(loss)
loss_summ = tf.scalar_summary('loss', loss)
और यहाँ प्रशिक्षण:
इस नेटवर्क है:
अंत में यहाँ कोड है
# 0 => left
# 1 => up
# 2 => right
# 3 => down
# 4 = noop
ACTIONS = 5
GAMMA = 0.95
BATCH = 50
TRANSITIONS = 2000
OBSERVATIONS = 1000
MAXSTEPS = 1000
D = deque()
epsilon = 1
average = 0
for episode in xrange(1000):
step_count = 0
game_ended = False
state = np.array([0.0]*100, float).reshape(100)
state[0] = 1
rsh_state = state.reshape(10,10)
s = np.stack((rsh_state, rsh_state, rsh_state, rsh_state), axis=2)
while step_count < MAXSTEPS and not game_ended:
reward = 0
step_count += 1
read = readout.eval(feed_dict={x: [s]})[0]
act = np.zeros(ACTIONS)
action = random.randint(0,4)
if len(D) > OBSERVATIONS and random.random() > epsilon:
action = np.argmax(read)
act[action] = 1
# play the game
pos_idx = state.argmax(axis=0)
pos = pos_idx + 1
state[pos_idx] = 0
if action == 0 and pos%10 != 1: #left
state[pos_idx-1] = 1
elif action == 1 and pos > 10: #up
state[pos_idx-10] = 1
elif action == 2 and pos%10 != 0: #right
state[pos_idx+1] = 1
elif action == 3 and pos < 91: #down
state[pos_idx+10] = 1
else: #noop
state[pos_idx] = 1
pass
if state.argmax(axis=0) == pos_idx and reward > 0:
reward -= 0.0001
if step_count == MAXSTEPS:
reward -= 100
elif state[99] == 1: # reward & finished
reward += 100
game_ended = True
else:
reward -= 1
s_old = np.copy(s)
s = np.append(s[:,:,1:], state.reshape(10,10,1), axis=2)
D.append((s_old, act, reward, s))
if len(D) > TRANSITIONS:
D.popleft()
if len(D) > OBSERVATIONS:
minibatch = random.sample(D, BATCH)
s_j_batch = [d[0] for d in minibatch]
a_batch = [d[1] for d in minibatch]
r_batch = [d[2] for d in minibatch]
s_j1_batch = [d[3] for d in minibatch]
readout_j1_batch = readout.eval(feed_dict={x:s_j1_batch})
y_batch = []
for i in xrange(0, len(minibatch)):
y_batch.append(r_batch[i] + GAMMA * np.max(readout_j1_batch[i]))
train.run(feed_dict={x: s_j_batch, y: y_batch, a: a_batch})
if epsilon > 0.05:
epsilon -= 0.01
मैं हर मदद और विचारों को आप हो सकता है की सराहना करते हैं!
मेरी पहली वृत्ति convolutions की परतों है और अधिकतम पूलिंग एजेंट ग्रिड/वस्तुओं/खिलाड़ियों, एक gridworld में महत्व के बारे में कुछ के स्थान में विस्तार से कम करने के लिए कारण बनता है। संभवतः अधिकतम पूल के बजाय एक औसत पूल का उपयोग करने का प्रयास करें? – Adam
मेरा आयनसर देखें लेकिन फिर भी कुछ और अंदरूनी होने के लिए धन्यवाद, लेकिन कुछ समय देखने की कोशिश करने के लिए आईटी शायद योग्य हो सकता है :) – natschz
अच्छा सवाल है, मैं लगभग 5 सप्ताह तक एक ही समस्या का सामना कर रहा हूं और यह पता नहीं लगा सकता कि वहां क्या गलत है। नेटवर्क को हानि मूल्यों की जांच करके अभिसरण किया जाता है लेकिन 100 चरणों का इनाम अभी भी बहुत कम है। मुझे डीक्यूएन डीबगिंग पर और अधिक काम करने की ज़रूरत है, नेटवर्क को सरल बनाना एक विकल्प है (मैं नेटवर्क में बहुत सी चीजें जोड़ता हूं: सीएनएन/ड्यूएल-डीक्यूएन/डबल डीक्यूएन ...)। –