Konvolutionelles neuronales Netzwerk: Wie man es trainiert? (unbeaufsichtigt)

Question

Ich versuche ein CNN zu implementieren, um ein Spiel zu spielen. Ich benutze Python mit Theano/Lasagne. Ich habe das Netzwerk aufgebaut und finde jetzt heraus, wie ich es trainieren kann.

So, jetzt habe ich einen Stapel von 32 Staaten und für jeden Zustand in diesem Charge der Aktion und die erwarteten Belohnungen für diese Aktion.

Nun, wie kann ich das Netzwerk trainieren, so dass es lernen, dass diese Aktionen in diesen Staaten zu diesen Belohnungen führen?

EDIT: Klärung meines Problems.

Hier ist mein vollständiger Code: http://pastebin.com/zY8w98Ng Die Schlange Import: http://pastebin.com/fgGCabzR

Ich habe Probleme mit diesem Bit:

def _train(self): 
    # Prepare Theano variables for inputs and targets 
    input_var = T.tensor4('inputs') 
    target_var = T.ivector('targets') 
    states = T.tensor4('states') 
    print "sampling mini batch..." 
    # sample a mini_batch to train on 
    mini_batch = random.sample(self._observations, self.MINI_BATCH_SIZE) 
    # get the batch variables 
    previous_states = [d[self.OBS_LAST_STATE_INDEX] for d in mini_batch] 
    actions = [d[self.OBS_ACTION_INDEX] for d in mini_batch] 
    rewards = [d[self.OBS_REWARD_INDEX] for d in mini_batch] 
    current_states = np.array([d[self.OBS_CURRENT_STATE_INDEX] for d in mini_batch]) 
    agents_expected_reward = [] 
    # print np.rollaxis(current_states, 3, 1).shape 
    print "compiling current states..." 
    current_states = np.rollaxis(current_states, 3, 1) 
    current_states = theano.compile.sharedvalue.shared(current_states) 

    print "getting network output from current states..." 
    agents_reward_per_action = lasagne.layers.get_output(self._output_layer, current_states) 


    print "rewards adding..." 
    for i in range(len(mini_batch)): 
     if mini_batch[i][self.OBS_TERMINAL_INDEX]: 
      # this was a terminal frame so need so scale future reward... 
      agents_expected_reward.append(rewards[i]) 
     else: 
      agents_expected_reward.append(
       rewards[i] + self.FUTURE_REWARD_DISCOUNT * np.max(agents_reward_per_action[i].eval())) 

    # figure out how to train the model (self._output_layer) with previous_states, 
    # actions and agent_expected_rewards 

ich das Modell mit previous_states, Aktionen aktualisieren mag, und agent_expected_rewards so dass es lernt, dass diese Handlungen zu diesen Belohnungen führen.

Ich erwarte, dass es so etwas wie dies aussehen könnte:

train_model = theano.function(inputs=[input_var], 
    outputs=self._output_layer, 
    givens={ 
     states: previous_states, 
     rewards: agents_expected_reward 
     expected_rewards: agents_expected_reward) 

ich einfach nicht, wie die Gegebenheiten des Modells bewirken würde, weil, wenn das Netzwerk den Aufbau ich sie nicht angeben. Ich kann es auch nicht in der Theano- und Lasagne-Dokumentation finden.

Also wie kann ich das Modell/Netzwerk aktualisieren, so dass es "lernt".

Wenn es noch nicht klar ist, kommentieren Sie, welche Informationen noch benötigt werden. Ich habe versucht, das jetzt für ein paar Tage herauszufinden.

Answer 1

Nachdem ich die Dokumentation durchgegangen bin, habe ich endlich die Antwort gefunden. Ich habe vorher an den falschen Stellen gesucht.

network = self._output_layer 
    prediction = lasagne.layers.get_output(network) 
    loss = lasagne.objectives.categorical_crossentropy(prediction, target_var) 
    loss = loss.mean() 

    params = lasagne.layers.get_all_params(network, trainable=True) 
    updates = lasagne.updates.sgd(loss, params, self.LEARN_RATE) 
    givens = { 
     states: current_states, 
     expected: agents_expected_reward, 
     real_rewards: rewards 
    } 
    train_fn = theano.function([input_var, target_var], loss, 
            updates=updates, on_unused_input='warn', 
            givens=givens, 
            allow_input_downcast='True') 
    train_fn(current_states, agents_expected_reward)