Novembre 2018

Volume 33 Numero 11

Artificially Intelligent - ingrandire esaminare apprendimento per rinforzo

Dal Frank La La

Nell'articolo del mese scorso, esplorato alcuni concetti di base di rinforzo apprendimento (RL), il tentativo di entrambi un approccio esclusivamente casuale per lo spostamento di un ambiente semplice e implementando quindi una tabella di domande e per indicare che le azioni precedenti e le azioni che ha portato a quale premi. Nella demo, un agente che opera in modo casuale è stato in grado di raggiungere lo stato dell'obiettivo circa 1 percentuale del tempo di e circa la metà del tempo quando si usa una tabella di domande e ricordare le operazioni precedenti. Tuttavia, questo esperimento solo un'idea del campo promessa e l'espansione della RL.

Si tenga presente che nella colonna precedente (msdn.com/magazine/mt830356), uno spazio di problema RL è costituito da un ambiente, un agente, azioni, gli Stati e premi. Un agente esamina lo stato di un ambiente e intraprende un'azione. Quindi l'azione viene modificato lo stato dell'agente e/o ambiente. L'agente riceve un premio ed esamina lo stato aggiornato del relativo ambiente. Quindi il ciclo viene riavviato e viene eseguito per un numero di iterazioni fino a quando l'agente ha esito positivo o esito negativo in un obiettivo predefinito. Quando un agente ha esito positivo o negativo, la simulazione termina. Con una tabella di D, un agente ricorda le azioni che hanno restituito premi positivi e fa riferimento a prendere decisioni nelle simulazioni successive.

Problema delle slot Machine

Uno dei problemi in RL classiche è la tensione tra esplorazione e sfruttamento delle vulnerabilità. Le macchine di slot, noto anche come "one-armed bandits" sono l'ispirazione per questo problema. Una banca di slot macchine crea quindi "delle slot Machine". Ognuno di questi computer slot ha una probabilità di il pagamento di una vincita o No. La probabilità di ogni turno causando un vincita può essere rappresentata come P e la probabilità di non pagare è 1 – P.  Se un computer ha una probabilità di vincita (JP) di,5, quindi ogni pull della leva hanno la stessa possibilità di vincita o la perdita. Al contrario, un computer con un JP di 0,1 potrebbe ottenere un risultato non confermato il 90% del tempo.

A questo punto, si immagini una banca di cinque macchine slot e giocatore (o agente) ha l'obiettivo di ottimizzare ricevuti e ridurre al minimo le perdite. Con alcuna conoscenza di qualsiasi della probabilità di vincita delle macchine (JP), l'agente è necessario eseguire alcuni rischi a prima. Con il primo pull della leva, l'agente wins e riceve un pagamento. Tuttavia, i tentativi successivi rivelano che questa macchina paga out circa la metà dei casi, un JP di.54. Man mano che procede macchine slot, si tratta piuttosto notevole. L'agente deve decidere se è necessario sfruttare corrente risorsa nota o esplorare una nuova macchina. Se la probabilità che la prima macchina nello slot il pagamento di generoso questo, è la pena di provare una o più macchine nella banca per verificare se sono preferibili le probabilità relative ai proventi?

Il modo migliore per esplorare ulteriormente questo spazio dei problemi è con codice Python in un notebook di Jupyter. Creare un notebook Python 3 sulla tua piattaforma preferita. Mi sono occupato il notebook di Jupyter in un articolo precedente (msdn.com/magazine/mt829269). Creare una cella vuota e immettere il codice seguente ed eseguire la cella.

import numpy as np
import matplotlib.pyplot as plt
number_of_slot_machines = 5
np.random.seed(100)
JPs =  np.random.uniform(0,1, number_of_slot_machines)
print(JPs)
plt.bar(np.arange(len(JPs)),JPs)
plt.show()

L'output dovrebbe leggere e Mostra un grafico dei valori, come illustrato nella figura 1.

[0.54340494 0.27836939 0.42451759 0.84477613 0.00471886]

Figura 1 le probabilità di vincita delle cinque macchine Slot

Il codice crea una matrice di valori JP per una serie di cinque macchine slot compreso 0,004 0.844. Tuttavia, il primo computer l'agente ha provato, mentre più elastico, non è la migliore. Chiaramente, la macchina slot quarta con una frequenza dei proventi 84.4% è la migliore pagando macchina nell'ambiente. È anche importante notare che la macchina di slot finale abbia le probabilità peggiori di pagare out un vincita. Ricordare che l'agente non dispone di alcuna conoscenza pregressa di alle tariffe di pagamento ed è necessario eseguirne l'individuazione di per sé. L'agente era non rimasto nella prima macchina, scegliendo lo sfruttamento su esplorazione, l'agente mai ha rilevato il meglio il pagamento delle slot machine.

Per rappresentare cosa conosce l'agente all'inizio di una simulazione, aggiungere il codice seguente in una nuova cella:

known_JPs = np.zeros(number_of_slot_machines)

In questo modo viene creata una matrice di zero, vale a dire che l'agente presuppone che JP di ogni macchina dello slot è uguale a zero. Mentre questo potrebbe non essere il valore iniziale ottimale in tutti i casi, è sufficiente per il nostro scopo. Per creare una simulazione di una macchina di slot, aggiungere il codice seguente in una nuova cella ed eseguirlo:

def play_machine(slot_machine):
  x = np.random.uniform(0, 1)
  if (x <= JPs[slot_machine]):
    return(10)
  else:
    return(-1)

Questo frammento di codice consente di simulare un computer nello slot il pagamento di un premio di 10 se il computer è a carico e un premio negativo-1 se la macchina non. Probabilità di un pagamento sono basati sul rischio definito nella matrice JPs numpy. Per testare il codice, immettere il seguente codice Python in una nuova cella ed eseguire:

# Test Slot Machine 4
for machines in range(10):
  print(play_machine(3))
print ("------")      
# Test Slot Machine 5
for machines in range(10):
  print(play_machine(4))

Questo codice mette a confronto le migliori prestazioni macchina con la macchina peggiori. Poiché questo è tutto basato su probabilità, non c'è garanzia dei risultati output. I risultati devono riflettere che, con la maggior parte dei 10 valori per computer 4 e quasi tutti i valori di-1 per la macchina 5. Con il codice macchina slot simulato si comporta come previsto, sarà il momento di esaminare un algoritmo più comune in RL: Epsilon Greedy.

L'algoritmo Greedy Epsilon

Il dilemma core dell'agente sia rivolto qui indica se la priorità al bersaglio, l'intenzione di sfruttare una risorsa nota, o curiosità, il desiderio di esplorare altre macchine dello slot nella speranza di un'ulteriore possibilità di premi. Uno degli algoritmi più semplici per risolvere questo problema è noto come l'algoritmo Epsilon Greedy, in cui l'agente sceglie in modo casuale tra l'uso della macchina di slot con le probabilità di proventi osservato fino a quel momento o provare un altro computer nella speranza che è possibile che sia migliore fornire un migliore relative ai proventi. Con un valore basso di Epsilon, questo algoritmo segue l'algoritmo greedy, ma occasionalmente cercherà un altro computer dello slot. Ad esempio, se il valore Epsilon è.1, l'algoritmo opterà per sfruttare il 90% del tempo ed esplorare solo il 10% del tempo. In genere, valori predefiniti di Epsilon tendono a risultano problemi tra.05 e. 1. In breve, l'agente riprodurrà principalmente il meglio dello slot computer individuato che riconosce e provare a volte una nuova macchina. Tenere presente che ogni pull della leva ha un costo e l'agente non sa cosa sappiamo: tale slot 4 ha acquistato la scelta migliore.

Ciò evidenzia la nozione di RL. L'agente non riconosce l'ambiente inizialmente, pertanto è necessario prima di tutto esplorare e quindi sfruttare in un secondo momento. Formazione continua in tutto l'intero processo. In pratica, questo è il concetto di soddisfazione ritardata e si trova in di interesse dell'agente non devono essere completamente greedy pertanto lascia spazio per l'esplorazione.

Verifica l'ipotesi Greedy Epsilon

Per verificare questa ipotesi, aggiungere il codice nel figura 2 a una nuova cella ed eseguirlo. Questo codice crea la funzione multi_armed_bandit, che simula una serie di esecuzioni per una raccolta di macchine. La funzione archivia le probabilità di un pagamento vincita osservate. A ogni iterazione, l'agente di riprodurre in modo casuale la macchina di slot con il migliore dei proventi che si è osservato fino a quel momento o arbitrariamente provare un altro computer. La funzione argmax restituisce il valore massimo nella matrice numpy. In questo caso, ciò significa che la macchina di slot con le migliori probabilità di raggiungere un vincita. Parametri della funzione consentono di controllare il numero di slot macchine, la quantità di iterazioni da eseguire e il valore di epsilon. 

Codice di apprendimento per rinforzo figura 2

def multi_armed_bandit(arms, iterations, epsilon):
  total_reward, optimal_action = [], []
  estimated_payout_odds = np.zeros(arms)
  count = np.zeros(arms)
  for i in range(0, iterations):
    epsilon_random = np.random.uniform(0, 1)
    if epsilon_random > epsilon :
      # exploit
      action = np.argmax(estimated_payout_odds)
    else :
      # explore
      action = np.random.choice(np.arange(arms))
    reward = play_machine(action)
    estimated_payout_odds[action] = estimated_payout_odds[action] +
      (1/(count[action]+1)) *
      (reward - estimated_payout_odds[action])
    total_reward.append(reward)
    optimal_action.append(action == np.argmax(estimated_payout_odds))
    count[action] += 1
  return(estimated_payout_odds, total_reward)

Con il codice RL posto, a questo punto è possibile testare l'algoritmo Epsilon Greedy. Immettere il codice dal figura 3 in una classe vuota cella ed eseguirlo. I risultati mostrano il grafico dal figura 1 per semplificarne la consultazione al, seguito dalle probabilità che il codice RL osservato.

Figura 3 Code per confrontare le probabilità di computer Slot effettivo e le osservazioni dell'agente

print ("Actual Odds")
plt.bar(np.arange(len(JPs)),JPs)
plt.show()
print (JPs)
print("----------------------------------")
iterations = 1000
print("\n----------------------------------")
print ("Learned Odds with epsilon of .1")
print("----------------------------------")
learned_payout_odds, reward = multi_armed_bandit(number_of_slot_machines, iterations, .1)
plt.bar(np.arange(len(learned_payout_odds)),learned_payout_odds)
plt.show()
print (learned_payout_odds)
print ("Reward: ", sum(reward))

Come si può notare nel figura 4, l'algoritmo ha un lavoro eccellente, non solo che determina la macchina di slot con le probabilità più vantaggiose, ma anche produrre le probabilità piuttosto accurata dei proventi per gli altri quattro slot macchine. I grafici vengono allineati piuttosto bene. Fatta eccezione per la macchina slot quinta, che ha tale bassa probabilità di un pagamento che assegnato un punteggio negativamente in osservazioni dell'agente.

Figura 4 risultati con un valore Epsilon 1

A questo punto, con la linea di base stabilita, è possibile sperimentare ulteriormente. Che cosa accadrebbe se epsilon sono stati impostati su zero, vale a dire che l'algoritmo non esaminerà mai? Immettere il codice seguente in una nuova cella ed eseguirlo per eseguire l'esperimento:

print("\n----------------------------------")
print ("Learned Odds with epsilon of 0")
print("----------------------------------")
learned_payout_odds, reward =
  multi_armed_bandit(number_of_slot_machines, iterations, 0)
plt.bar(np.arange(len(learned_payout_odds)),learned_payout_odds)
plt.show()
print (learned_payout_odds)
print ("Reward: ", sum(reward))

Viene illustrato il grafico risultante con un valore maggiore di zero. Un solo computer domina gli altri, rendendo molto evidente che l'agente di trovata una macchina e bloccata con esso. Tuttavia, eseguire il codice più volte ed è possibile osservare che sviluppa di uno schema interessante in alcuni casi. Saranno presenti uno o più computer con i valori negativi, con un computer con un livello più elevato rispetto a valore zero. In questi casi, l'agente ha perso in un determinato computer e quindi ha vinto in un altro computer. Una volta che l'agente consente di individuare un computer vincente, atterrò con tale computer, quanto sarà computer in cui la funzione argmax sceglierà. Se epsilon è impostato su zero, l'agente potrebbe comunque esplorare, ma non è intenzionale. Di conseguenza, le probabilità di osservato slot machine lontano sono le effettive probabilità. È anche importante notare che il metodo "greedy" produce un punteggio di reward inferiore rispetto a cui è stata impostata epsilon a.1. Bersaglio, bersaglio almeno assoluto, verrà visualizzato un risultare controproducente.

Cosa se epsilon fosse impostato su 1, eseguendo l'agente di esplorare ogni volta e non sfruttare affatto? Immettere il codice seguente in una nuova cella ed eseguirlo:

print("\n----------------------------------")
print ("Learned Odds with epsilon of 1")
print("----------------------------------")
learned_payout_odds, reward  = multi_armed_bandit(number_of_slot_machines, iterations, 1)
plt.bar(np.arange(len(learned_payout_odds)),learned_payout_odds)
plt.show()
print (learned_payout_odds)
print ("Reward: ", sum(reward))

I risultati mostreranno che l'agente ha un lavoro eccellente osservando simili a quelle di quante probabilità ci true e linee del grafico di strettamente con odds figura 1. In effetti, i risultati di epsilon impostazione su 1 sembrano molto simili a cui il valore è stato.1. Tuttavia, prendere nota del valore di ricompensa, e c'è una forte differenza. Il valore di reward quando epsilon è stata impostata su.1 sarà quasi sempre maggiore di quando è impostata su 1. Quando l'agente è impostato su solo esplorare, verrà effettuato un tentativo con un computer in modo casuale a ogni iterazione. Mentre potrebbe essere imparare dal osservazione, non agisce su quelle osservazioni.

Conclusioni

RL rimane uno degli spazi più interessanti di intelligenza artificiale. In questo articolo, esaminato l'algoritmo Greedy Epsilon con il classico problema di "Multi-Armed delle slot", esaminando il dilemma Esplora o exploit specificamente che devono affrontare gli agenti. Consiglia di esplorare ulteriormente i compromessi eseguendo più esperimenti con diversi valori di epsilon e maggiori quantità di slot per le macchine.

Frank La Vignelavora in Microsoft come un professionista di soluzioni di tecnologia di intelligenza artificiale in cui aiuta le aziende ottenere migliori risultati per usufruire al meglio i propri dati con analitica e intelligenza artificiale. Ha inoltre CO-host il DataDriven podcast. Il suo blog all'indirizzo FranksWorld.com ed è possibile guardare lui sul suo canale YouTube, "Di Frank mondo TV" (FranksWorld.TV).

Grazie al seguente esperto tecnico per la revisione dell'articolo: Andy Leonard

Discutere di questo articolo nel forum di MSDN Magazine