---

Giugno 2016

Volume 31 Numero 6

Il presente articolo è stato tradotto automaticamente.

Esecuzione di test - Introduzione ai mercati predittivi

Da James McCaffrey

Si supponga di che voler stimare il risultato di un gioco di football championship future tra il Xrays e il Yanks. Per trovare un gruppo di esperti di football 20 e assegnare a ognuno $500 nei token. Esperti possono acquistare e vendere quote di ciascuno dei due gruppi, in modo che è simile al funzionamento del mercato azionario.

Quando un esperto acquista condivisioni in un team, ad esempio Xrays, il prezzo di una condivisione di quel team aumenta o diminuisce il prezzo di una condivisione di altri team. Nel corso del tempo, esperti verranno acquistare e vendere condivisioni dei due team fino a quando non si stabilizzano prezzi e sarà in grado di dedurre la probabilità di vincere ogni team.

Si arresta il giorno prima del gioco championship commerciali. Dopo la riga confermata viene determinata viene riprodotto il gioco, si paga esperti che hanno quote nel team vincente in base al prezzo ultimo del team di chiusura commerciali. Poiché gli esperti conoscono che verrà pagato, hanno incentivi a formulare i pareri true durante la negoziazione.

Quello che ho appena descritto, si tratta di un mercato di stima. In questo articolo, sarà descrivono i calcoli matematici dietro mercati di stima e viene illustrato come implementare le funzioni nel codice. È improbabile sarà mai necessario creare un mercato stima il lavoro quotidiano, ma credo che troverete le idee molto interessante. Inoltre, alcune delle tecniche di programmazione presentate in questo articolo utilizzabili in scenari di sviluppo software più comuni.

Questo articolo si presuppone almeno per principianti a livello di competenza di codifica, ma non si supponga che si conoscono i mercati di stima. Presenterò un programma di dimostrazione completo e dal download che accompagna questo articolo, è inoltre possibile ottenere il codice sorgente. La demo Usa c#, ma è non necessario alcun problema di refactoring del codice in un altro linguaggio, se si desidera.

Si noti che questa è un'introduzione informale ai mercati di stima, destinato principalmente agli sviluppatori di software. Prendo alcuni liberamente con la terminologia e le definizioni per mantenere le idee più chiare possibili.

esempio

Mercati rappresentano probabilmente la scelta migliori stima illustrato con un esempio concreto. Guardate il programma demo in Figura 1. Dopo alcuni messaggi preliminare, l'output di demo inizia con:

Setting liquidity parameter = 100.0

Initial number of shares owned of teams [0] and [1] are:
0 0

Initial inferred probabilities of winning are:
 0.5000  0.5000

Figura 1 stima mercato Demo

Il parametro di liquidità verrà spiegato in dettaglio, ma per ora è sufficiente sapere che liquidità controlla quanto di mercato rispondere all'acquisto e la vendita. Valori più alti di liquidità producono più piccole variazioni dei prezzi.

Inizialmente, Nessuna condivisione sono di proprietà da esperti. Poiché il numero di azioni possedute per ogni team è lo stesso (zero), è ragionevole che iniziale dedotto probabilità che avrà un team è 0,50.

È la parte successiva dell'output demo:

Current costs for one share of each team are:
 $0.5012  $0.5012

In qualsiasi momento, una condivisione di ogni team dispone di un determinato prezzo. Esperti necessario conoscere il prezzo, in quanto sono in corso la riproduzione di denaro. Poiché le probabilità di vincere iniziale sono uguali, è ragionevole che i prezzi per una condivisione di ogni team sono uguali.

È la parte successiva dell'output demo:

Update: expert [01] buys 20 shares of team [0]

Cost of transaction to expert was: $10.50

Esperto #1 ritiene che tale team 0, Xrays, avrà la precedenza e acquista 20 condivisioni del team di 0. Il costo per l'esperto è $10,50. Si noti che il prezzo per le 20 condivisioni ($10,50) non corrisponde a 20 volte il prezzo di una singola condivisione (20 * $0.5012 = $10.02). Ogni azione è stato acquistato, aumenta il prezzo di una condivisione del team. È la parte successiva dell'output demo:

New number of shares owned of teams [0] and [1] are:
20 0

New inferred probabilities of winning are:
 0.5498  0.4502

La demo Visualizza il numero di azioni in circolazione aggiornato in ogni team, (x, y) = (20, 0) e calcola e Visualizza aggiornato dedotto le probabilità di vincere ogni team (0,55, 0,45). Poiché gli esperti hanno acquistato più condivisioni di team 0 di 1 del team, la probabilità di vincere team 0 derivata deve essere maggiore di quello del team di 1. Verrà spiegato il calcolo delle probabilità.

Successivamente, Visualizza la demo:

Current costs for one share of each team are:
 $0.5511  $0.4514

Update: expert [02] buys 20 shares of team [1]

Cost of transaction to expert was: $9.50

Il nuovo costo per ogni condivisione per ogni team viene calcolato e visualizzato. Si noti che il prezzo di una condivisione di team 0 ($0,55) è ora molto più costoso rispetto a quello del team 1 (0,45 dollari). In questo modo gli esperti un incentivo per acquistare azioni del team 1 se si ritiene che il prezzo è un buon valore relativo alla probabilità di vincere team 1. In questo caso, la demo simula acquisto 20 condivisioni del team 1 per un costo di $9.50 esperti #2. Successivo:

New number of shares owned of teams [0] and [1] are:
20 20

New inferred probabilities of winning are:
 0.5000  0.5000

Esistono ora 20 azioni in sospeso per ogni team, quindi ripristino le probabilità di vincere ogni team dedotto 0,50 e 0,50.

È la parte successiva dell'output demo:

Current costs for one share of each team are:
 $0.5012  $0.5012

Update: expert [03] buys 60 shares of team [0]
Cost of transaction to expert was: $34.43

New number of shares owned of teams [0] and [1] are:
80 20

New inferred probabilities of winning are:
 0.6457  0.3543

Esperto in #3 fortemente ritiene che avrà team 0, in modo che acquista 60 condivisioni del team 0 per un costo di $34.43. Questa transazione modifica il numero di azioni in circolazione per (80, 20) e fa sì che le probabilità nuovo derivate di dominante per spostare fortemente verso team 0 (0,65, 0.35).

Quindi, esperti vede #1 che il valore della sua condivisioni in team 0 hanno aumentato notevolmente a circa 0.6468 per ogni condivisione:

Current costs for one share of each team are:
 $0.6468  $0.3555

Update: expert [01] sells 10 shares of team [0]
Cost of transaction to expert was: $-6.34

New number of shares owned of teams [0] and [1] are:
70 20

New inferred probabilities of winning are:
 0.6225  0.3775

Esperto di #1 ritiene team 0 è ora in qualche modo overpriced rispetto al relativo possibilità di vincere e vende 10 del suo 20 condivisioni, recupero $6.34 (indicata con il segno negativo). Il nuovo dedotto probabilità modificano nuovamente per un po' più uguale, ma team 0 è ancora previsto per vincere con probabilità 0,63.

La demo è terminata chiudendo commerciali. Le probabilità finale sono l'obiettivo del mercato stima. Dopo che viene riprodotto il gioco tra il Xrays e il Yanks, esperti sarebbero pagati per le condivisioni che possono contenere un numero nel team vincente, in base al prezzo di condivisione finale del team vincente. I pagamenti incoraggiano gli esperti a formulare i pareri true.

Le equazioni di mercato stima chiave quattro

Un mercato di stima di base utilizza quattro equazioni matematiche, come illustrato nella Figura 2. Tenere con me. le equazioni sono quasi complicate come appaiono prima. Sono disponibili diversi modelli di matematica che possono essere utilizzati per definire un mercato di stima. Il modello presentato in questo articolo si basa su ciò che viene definito il protocollo logaritmica mercato punteggio regola (LMSR).

Figura 2 le equazioni di mercato stima chiave quattro

Equazione 1 è la funzione di costo associata a un set di azioni in sospeso (x, y). L'equazione, che non è del tutto ovvio, proviene dalla teoria economia. Dal punto di vista dello sviluppatore, è possibile considerare l'equazione come una funzione di supporto. Accetta x, ovvero il numero di condivisioni utilizzate dell'opzione 0 e y, ovvero il numero di condivisioni utilizzate dell'opzione 1 e restituisce un valore. Variabile b in tutte e quattro le equazioni è il parametro di liquidità. Si supponga che x = 20 e y = 10. Se b = 100,0, quindi C(x,y) = 100,0 * ln(exp(20/100) + exp(10/100)) = 100,0 * ln (1.22 + 1.11) = 100,0 * 0.8444 = $84.44. Il valore restituito viene utilizzato nell'equazione 2.

Equazione 2 è il costo di una transazione per un acquirente. Si supponga che sia un set di azioni in circolazione corrente (20, 10) e un esperto acquista 30 condivisioni dell'opzione 0. Il costo della transazione per l'esperto viene calcolato utilizzando la formula 2 come C (20 + 30, 10) - C (20, 10) = C (50, 10) - C (20, 10) = 101.30 84.44 = $16.86. Se un esperto vende condivisioni, il costo della transazione sarà un valore negativo che indica che l'esperto è a pagamento.

Equazione 3 è tecnicamente prezzo marginale dell'opzione 0 in base a un set di azioni in sospeso (x, y). Ma un prezzo marginale può essere interpretato liberamente con la probabilità che un'opzione avrà la precedenza. Equazione 4 è il prezzo marginale (probabilità) dell'opzione 1. Se si osserva attentamente le due equazioni, si noterà che deve essere pari a 1,0, come richiesto per un set di probabilità.

Implementazione di equazioni di mercato stima chiave quattro è semplice. Il programma demo implementa il costo, l'equazione 1, come:

static double Cost(int[] outstanding, double liq)
{
  double sum = 0.0;
  for (int i = 0; i < 2; ++i)
    sum += Math.Exp(outstanding[i] / liq);
  return liq * Math.Log(sum);
}

Il metodo di costo è sostanzialmente una traduzione precisa dell'equazione 1. Il metodo di notifica costo presuppone che esistono solo due opzioni. Per semplicità, non viene eseguito alcun controllo degli errori.

Equazione 2 è piuttosto semplice da implementare:

static double CostOfTrans(int[] outstanding, int idx, int nShares, double liq)
{
  int[] after = new int[2];
  Array.Copy(outstanding, after, 2);
  after[idx] += nShares;
  return Cost(after, liq) - Cost(outstanding, liq);
}

La matrice denominata dopo contiene il nuovo numero di azioni in circolazione dopo una transazione e il metodo quindi chiama semplicemente il metodo helper costo due volte. Con un metodo per calcolare il costo di una transazione in corso, è facile scrivere un metodo che calcola il costo di acquisto di una singola condivisione di ciascuna delle due opzioni:

static double[] CostForOneShare(int[] outstanding, double liq)
{
  double[] result = new double[2];
  result[0] = CostOfTrans(outstanding, 0, 1, liq);
  result[1] = CostOfTrans(outstanding, 1, 1, liq);
  return result;
}

Il costo di una singola condivisione è utilizzabile da esperti per ottenere un'approssimazione della quantità al costo di acquistare n azioni di un'opzione.

Metodo probabilità restituisce due prezzi marginali (probabilità derivato) di ogni opzione vincente in una matrice:

static double[] Probabilities(int[] outstanding, double liq)
{
  double[] result = new double[2];
  double denom = 0.0;
  for (int i = 0; i < 2; ++i)
    denom += Math.Exp(outstanding[i] / liq);
  for (int i = 0; i < 2; ++i)
    result[i] = Math.Exp(outstanding[i] / liq) / denom;
  return result;
}

Se si confronta il codice del metodo probabilità con equazioni 3 e 4, si noterà che, anche in questo caso, il codice segue direttamente dalla definizione di matematica.

Il programma Demo

Per creare il programma demo, ho avviato Visual Studio e selezionare il modello del programma c# console application. È denominato PredictionMarket il progetto. La demo senza dipendenze significativi Microsoft .NET Framework, pertanto funzionerà qualsiasi versione di Visual Studio.

Dopo aver caricato il codice del modello, nella finestra Esplora soluzioni rinominato file Program.cs per PredictionMarketProgram.cs più descrittivi e Visual Studio rinominare automaticamente classe Program per me è consentito. Nella parte superiore del codice sorgente, eliminato tutte le istruzioni using che a cui fa riferimento a spazi dei nomi .NET non necessari, lasciando solo il riferimento allo spazio dei nomi principale di sistema.

Il codice di dimostrazione completo, con poche e alcune istruzioni WriteLine eliminate per risparmiare spazio, viene presentato in Figura 3. Tutta la logica di controllo di programma si trova nel metodo Main. Tutte le funzionalità di mercato di stima sono in quattro metodi statici e sono disponibili due metodi di visualizzazione di supporto ShowVector.

Figura 3 stima mercato Demo

using System;
namespace PredictionMarket
{
  class PredictionMarketProgram
  {
    static void Main(string[] args)
    {
      Console.WriteLine("Begin prediction market demo ");
      Console.WriteLine("Goal is to predict winner of Xrays");
      Console.WriteLine("vs. Yanks using expert opinions");
      double liq = 100.0;
      Console.WriteLine("Setting liquidity parameter = " +
        liq.ToString("F1"));
      int[] outstanding = new int[] { 0, 0 };
      Console.WriteLine("Initial number of shares owned are:");
      ShowVector(outstanding);
      double[] probs = Probabilities(outstanding, liq);
      Console.WriteLine("Initial probabilities of winning:");
      ShowVector(probs, 4, " ");
      Console.WriteLine("=================================");
      double[] costPerShare = CostForOneShare(outstanding, liq);
      Console.WriteLine("Current costs for one share are: ");
      ShowVector(costPerShare, 4, " $");
      Console.WriteLine("Update: expert [01] buys 20 shares " +
        "of team [0]");
      double costTrans = CostOfTrans(outstanding, 0, 20, liq);
      Console.WriteLine("Cost of transaction to expert was: $" +
        costTrans.ToString("F2"));
      outstanding = new int[] { 20, 0 };
      Console.WriteLine("New number of shares owned are: ");
      ShowVector(outstanding);
      probs = Probabilities(outstanding, liq);
      Console.WriteLine("New inferred probs of winning:");
      ShowVector(probs, 4, " ");
      Console.WriteLine("=================================");
      costPerShare = CostForOneShare(outstanding, liq);
      Console.WriteLine("Current costs for one share are:");
      ShowVector(costPerShare, 4, " $");
      Console.WriteLine("Update: expert [02] buys 20 shares " +
        "of team [1]");
      costTrans = CostOfTrans(outstanding, 1, 20, liq);
      Console.WriteLine("Cost of transaction to expert was: $" +
        costTrans.ToString("F2"));
      outstanding = new int[] { 20, 20 };
      Console.WriteLine("New number of shares owned are:");
      ShowVector(outstanding);
      probs = Probabilities(outstanding, liq);
      Console.WriteLine("New inferred probs of winning:");
      ShowVector(probs, 4, " ");
      Console.WriteLine("=================================");
      costPerShare = CostForOneShare(outstanding, liq);
      Console.WriteLine("Current costs for one share are:");
      ShowVector(costPerShare, 4, " $");
      Console.WriteLine("Update: expert [03] buys 60 shares " +
        "of team [0]");
      costTrans = CostOfTrans(outstanding, 0, 60, liq);
      Console.WriteLine("Cost of transaction to expert was: $" +
        costTrans.ToString("F2"));
      outstanding = new int[] { 80, 20 };
      Console.WriteLine("New number of shares owned are:");
      ShowVector(outstanding);
      probs = Probabilities(outstanding, liq);
      Console.WriteLine("New inferred probs of winning:");
      ShowVector(probs, 4, " ");
      Console.WriteLine("=================================");
      costPerShare = CostForOneShare(outstanding, liq);
      Console.WriteLine("Current costs for one share are: ");
      ShowVector(costPerShare, 4, " $");
      Console.WriteLine("Update: expert [01] sells 10 shares " +
        "of team [0]");
      costTrans = CostOfTrans(outstanding, 0, -10, liq);
      Console.WriteLine("Cost of transaction to expert was: $" +
        costTrans.ToString("F2"));
      outstanding = new int[] { 70, 20 };
      Console.WriteLine("New number of shares owned are:");
      ShowVector(outstanding);
      probs = Probabilities(outstanding, liq);
      Console.WriteLine("New inferred probs of winning:");
      ShowVector(probs, 4, " ");
      Console.WriteLine("=================================");
      Console.WriteLine("Update: Market Closed");
      Console.WriteLine("\nEnd prediction market demo \n");
      Console.ReadLine();
    } // Main()
    static double[]Probabilities(int[] outstanding,
      double liq)
    {
      double[] result = new double[2];
      double denom = 0.0;
      for (int i = 0; i < 2; ++i)
        denom += Math.Exp(outstanding[i] / liq);
      for (int i = 0; i < 2; ++i)
        result[i] = Math.Exp(outstanding[i] / liq) / denom;
      return result;
    }
    static double Cost(int[] outstanding, double liq)
    {
      double sum = 0.0;
      for (int i = 0; i < 2; ++i)
        sum += Math.Exp(outstanding[i] / liq);
      return liq * Math.Log(sum);
    }
    static double CostOfTrans(int[] outstanding, int idx,
      int nShares, double liq)
    {
      int[] after = new int[2];
      Array.Copy(outstanding, after, 2);
      after[idx] += nShares;
      return Cost(after, liq) - Cost(outstanding, liq);
    }
    static double[] CostForOneShare(int[] outstanding,
      double liq)
    {
      double[] result = new double[2];
      result[0] = CostOfTrans(outstanding, 0, 1, liq);
      result[1] = CostOfTrans(outstanding, 1, 1, liq);
      return result;
    }
    static void ShowVector(double[] vector, int dec, string pre)
    {
      for (int i = 0; i < vector.Length; ++i)
        Console.Write(pre + vector[i].ToString("F" + dec) + " ");
      Console.WriteLine("\n");
    }
    static void ShowVector(int[] vector)
    {
      for (int i = 0; i < vector.Length; ++i)
        Console.Write(vector[i] + " ");
      Console.WriteLine("\n");
    }
  } // Program class
} // ns

Dopo la visualizzazione di alcuni messaggi preliminare, esecuzione del programma nel metodo Main inizia con:

double liq = 100.0;
int[] outstanding = new int[] { 0, 0 };
ShowVector(outstanding);

Variabile liq è il parametro di liquidità. Un valore di 100,0 è tipico, ma se proverete modificando il valore, verrà visualizzato il relativo impatto sulla modifica dei prezzi di condivisione dopo una transazione. Valori più alti di liquidità producono più piccole modifiche. La matrice denominata in sospeso contiene il numero totale di azioni possedute da tutti gli esperti, in ognuno dei due gruppi. Si noti che il parametro di liquidità deve essere passato ai metodi di stima mercato statico quattro. Un progetto alternativo è per incapsulare i metodi in una classe c# e definire liquidità come un campo membro.

Quindi, il numero di azioni in circolazione è utilizzato per determinare le probabilità di vincere ogni team derivate:

double[] probs = Probabilities(outstanding, liq);
Console.WriteLine("Initial probabilities of winning:");
ShowVector(probs, 4, " ");

La demo Visualizza quindi i costi di acquisto di una singola condivisione di ciascuno dei due gruppi:

double[] costPerShare = CostForOneShare(outstanding, liq);
Console.WriteLine("Current costs for one share are: ");
ShowVector(costPerShare, 4, " $");

In un mercato stima realistica, queste informazioni sarebbe utile per gli esperti di mercato per aiutarli a valutare se il prezzo di un team è troppo alta o troppo basso rispetto alla percezione dell'esperto che il team avrà la precedenza.

Il programma demo simula uno degli esperti acquisto alcune azioni, come illustrato di seguito:

Console.WriteLine("Update: expert [01] buys 20 shares of team [0]");
double costTrans = CostOfTrans(outstanding, 0, 20, liq);
Console.WriteLine("Cost of transaction to expert was: $" +
  costTrans.ToString("F2"));

In un mercato stima reale, il sistema deve mantenere una certa quantità di informazioni sui saldi dei conti degli esperti e il numero di azioni possedute.

Successivamente, il numero di azioni in circolazione è aggiornato, come illustrato di seguito:

outstanding = new int[] { 20, 0 };
Console.WriteLine("New number of shares owned on teams [0] " +
  "and [1] are: ");
ShowVector(outstanding);

Se si fa riferimento nuovamente le equazioni matematiche in Figura 2, si noterà che il numero di azioni in sospeso per ogni opzione o di team, (x, y), è necessario per tutte le equazioni.

Dopo aver aggiornato il numero di azioni in circolazione, tali informazioni viene utilizzate per stimare le probabilità di ogni team o dominante opzione modificate:

probs = Probabilities(outstanding, liq);
Console.WriteLine("New inferred probabilities of
  winning are: ");
ShowVector(probs, 4, " ");

Tenere presente che questi valori sono realmente marginali prezzi, ma può essere utile pensare come probabilità. In definitiva, lo scopo di un mercato di stima è la probabilità che ogni team o l'opzione avrà la precedenza, pertanto il set finale di probabilità dopo che il mercato si stabilizza è ciò che desideri.

Il programma demo è terminata ripetendo le operazioni seguenti cinque altre tre volte:

• Visualizza il costo corrente per una condivisione di ogni team
• Eseguire un acquisto o la vendita delle transazioni
• Visualizza il costo della transazione
• Aggiornare il numero totale di azioni in sospeso
• Aggiornare la probabilità di vincere ogni team

Si noti che il programma demo inizia con le probabilità di entrambi i team parità. Non è realistico in molti scenari reali stima-market. È possibile inizializzare un mercato di stima con probabilità diversi per la risoluzione per x e y in equazioni 3 e 4.

Avvolgendo

Le informazioni contenute in questo articolo si basano sul documento di 2002 ricerca "Logaritmica mercato punteggio regole per modulare combinatorio informazioni di aggregazione," da Robin Hanson. È possibile trovare una versione PDF del foglio in diverse posizioni in Internet tramite qualsiasi strumento di ricerca.

Mercati di stima non solo un'idea teorica astratta. Negli ultimi anni, sono state create più società che implementano effettivamente i mercati di stima per denaro reale.

Un'area di ricerca active è in ciò che vengono chiamati mercati stima combinatori complessi. Invece di selezionare solo una delle due opzioni per vincere, esperti possono acquistare condivisioni negli eventi di combinazione, ad esempio team saranno pressione team B e J Team saranno battute stima K. combinatorio team mercati sono molto più complessi dei mercati semplici.

---

Ripristino di emergenza. James McCaffreylavora per Microsoft Research a Redmond, Washington. Ha lavorato su numerosi prodotti Microsoft, inclusi Internet Explorer e Bing. Dr. È possibile contattarlo McCaffreyjammc@microsoft.com.

Grazie per i seguenti esperti tecnici Microsoft che ha esaminato in questo articolo: Pallavi Choudhury, Gaz Iqbal, Umesh Madan e Tien Suwandy