Einführung

Hallo, das ist gemächlich es gemächlich. (Mir wurde auf Twitter gesagt, dass es schwierig ist, gemächlich anzurufen.) Da ich kooperative Spieltheorie studiert habe, habe ich die Berechnung des Scherspielwerts nach der Überprüfung in Python implementiert. Ich habe nur implementiert, was ich von Hand durch Programmieren tun kann, und ich würde den Scherspielwert, der von Hand schwer zu finden wäre, nicht berechnen. Es scheint, dass R ein Paket hat, um den Scherspielwert zu berechnen, also sollten Sie R verwenden (ich frage mich, ob der Paketname mit R übereinstimmt). Es ist also ein Hobby, es umzusetzen.

Beginnen wir mit der Codierung nach einer kleinen Erklärung des Scherspielwerts.

· Verweise [Einführung in die Shigeo Muto-Spieltheorie](https://www.amazon.co.jp/%E3%82%B2%E3%83%BC%E3%83%A0%E7%90%86%E8%AB%96 % E5% 85% A5% E9% 96% 80-% E6% 97% A5% E7% B5% 8C% E6% 96% 87% E5% BA% AB% E2% 80% 95% E7% B5% 8C% E6% B8% 88% E5% AD% A6% E5% 85% A5% E9% 96% 80% E3% 82% B7% E3% 83% AA% E3% 83% BC% E3% 82% BA-% E6 % AD% A6% E8% 97% A4-% E6% BB% 8B% E5% A4% AB / dp / 4532108292 / ref = sr_1_5? __Mk_ja_JP =% E3% 82% AB% E3% 82% BF% E3% 82 % AB% E3% 83% 8A & crid = 3JR92N3EW4M6 & dchild = 1 & keywords =% E3% 82% B2% E3% 83% BC% E3% 83% A0% E7% 90% 86% E8% AB% 96% E5% 85% A5% E9% 96% 80 & qid = 1585324546 & sprefix = ge-murironnnyuumon% 2Caps% 2C373 & sr = 8-5) [Yukihiko Funaki Übungsspieltheorie](https://www.amazon.co.jp/%E6%BC%94%E7%BF%92%E3%82%B2%E3%83%BC%E3%83% A0% E7% 90% 86% E8% AB% 96-% E6% BC% 94% E7% BF% 92% E6% 96% B0% E7% B5% 8C% E6% B8% 88% E5% AD% A6 % E3% 83% A9% E3% 82% A4% E3% 83% 96% E3% 83% A9% E3% 83% AA-% E8% 88% B9% E6% 9C% A8-% E7% 94% B1 % E5% 96% 9C% E5% BD% A6 / dp / 4883840727 / ref = sr_1_1? __ mk_ja_JP =% E3% 82% AB% E3% 82% BF% E3% 82% AB% E3% 83% 8A & dchild = 1 & keywords = % E6% BC% 94% E7% BF% 92% E3% 82% B2% E3% 83% BC% E3% 83% A0% E7% 90% 86% E8% AB% 96 & qid = 1585323768 & sr = 8-1)

Übliche Hinweise

Der Zweck dieses Artikels besteht nicht darin, das Programmieren zu lernen, sondern die Wirtschaftlichkeit mit einem Tool namens Programmieren besser zu verstehen.
Wenn Sie Unzulänglichkeiten feststellen, hinterlassen Sie bitte einen Kommentar.
Ergänzung: Ich habe es nach dem Posten bemerkt, aber einige Leute haben es bereits in Python implementiert. "Beitragswert mit Shapley-Wert berechnen" von shiibass

Was ist der Scherspielwert?

Die Verteilung der Gewinne an jeden Spieler wird basierend auf dem Grad des Beitrags bestimmt, wobei berücksichtigt wird, wie viel jeder Spieler zur Bildung einer Partnerschaft beiträgt. In der Koop-Spieltheorie stellt sich die Frage, wie der Gewinn nach der Allianz verteilt werden soll, und ich interpretiere, dass eine der Möglichkeiten, ihn zu verteilen, der Scherspielwert ist. Es gibt auch Verhandlungssätze, Jin, Kernel usw. als Lösungskonzepte, aber ich denke, es ist einfacher, den Scherspielwert anzuwenden, der die Verteilung eindeutig bestimmt, wenn die Bedingungen erfüllt sind. (Hier gibt es nicht genug Studien.)

Der Scherspielwert wird aus vier Axiomen abgeleitet. ・ Allgemeine Rationalität ・ Eigenschaften in Bezug auf Nullspieler ・ Eigenschaften in Bezug auf symmetrische Spieler ・ Die Art der Summe des Spiels Es erfüllt die oben genannten Eigenschaften. Sherpley hat bewiesen, dass es nur eine Lösung gibt, die diese vier Eigenschaften erfüllt. Definieren wir nun die Formel für den Scherspielwert. $ v $: Charakteristische Funktion, $ S $: Angenommen, Sie haben eine Partnerschaft. Shearplay-Wert von Spieler $ i \ in N $ im Spiel $ (N, v) : $ \phi_i(v) = \sum_{S: i \in S \subseteq N} \frac{(s-1)!(n-s)!}{n!}(v(S)-v(S \setminus \{ i \} ))$ Hier,s = |S|, n = |N|Es wird gesagt. Ebenfalls, $ v(S)-v(S \setminus \{ i \} ) $$ Stellt den Grenzbeitrag von Spieler $ i \ in S $ in verbundenen $ S $ dar. Implementieren Sie die Berechnung dieses Scherspielwerts.

Codierung

Es gibt verschiedene Möglichkeiten, die Anzahl der Spieler und die zugehörigen Werte einzugeben, aber die Implementierung war für mich einfach. Siehe auch Auskommentieren im Code für weitere Details.

Generieren Sie eine Reihe von Spielern und Allianzen

Geben Sie zunächst die Anzahl der Spieler ein und erstellen Sie eine Reihe von Allianzen.

import itertools
import math

n = int(input()) #Geben Sie die Anzahl der Spieler ein

seq = [str(i+1) for i in range(n)] #Vorbereitung auf eine Reihe von Allianzen
All_set = []
for i in range(n): #Eine Reihe von Allianzen(aufführen)Generieren Sie a
    comb = list(itertools.combinations(seq,i+1)) 
　　#itertools.Generieren Sie eine einzigartige Kombination mit Kombination
    All_set.extend(comb)

new_All_set = ['0'] #Stellen Sie eine Partnerschaft von 0 Personen für eine spätere Berechnung ein
for i in range(len(All_set)): 
    #In der oben generierten Liste ist jede Verbindung ein Taple. Ändern Sie sie daher in str
    s=""
    a = All_set[i]
    for j in a:
        s += j
    new_All_set.append(s)

zero_set = list(0 for _ in range(len(new_All_set))) #Eine Menge aller 0 Allianzwerte(aufführen)

S = new_All_set #Eine Sammlung aller Allianzen(aufführen)
V = zero_set    #Satz aller verbundenen Werte(aufführen)Geben Sie danach den Verbindungswert ein. Immer noch 0 hier

Verbindungswert eingeben

Wenn der Bindungswert der Bindung zwischen Spieler 1 und 2 2 ist, geben Sie "12 2" ein. Ich denke nicht, dass es ordentlich ist, eine separate Liste von Allianz- und Allianzwertsätzen zu haben, aber persönlich war es einfacher, damit umzugehen.

for i in range(len(new_All_set)):
    inp = (input().split()) #Verarbeiten Sie hier die Eingabe des Bindungswerts
    if inp[0] in S: #Eingabeverarbeitung, wenn sich die eingegebene Allianz in der Gruppe der Allianzen befindet
        position = S.index(inp[0])
        V[position] = int(inp[1])
    if inp[0] == "ZERO":
        #Wenn alle verbleibenden einzugebenden Verbindungswerte 0 werden, geben Sie NULL ein, um die for-Anweisung zu beenden.
        break

Berechnung des Scherspielwerts

sv = []
for i in range(n):
    res = 0
    i_in = [s for s in S if str(i+1) in s] #Eine Reihe von Allianzen, zu denen ich gehöre(aufführen)
    i_not_in = [s for s in S if str(i+1) not in s] #Eine Reihe von Allianzen, zu denen ich nicht gehöre(aufführen)
    for j in range(len(i_in)):
        res += math.factorial(len(i_in[j])-1) * math.factorial(n-len(i_in[j])) / math.factorial(n) \
        * (V[S.index(i_in[j])] - V[S.index(i_not_in[j])])
    #Berechnen Sie hier den Scherspielwert
    sv.append(["player"+str(i+1) ,res]) #Listen Sie die Scherspielwerte jedes Spielers auf
print(sv)

das ist alles. Bevor ich es implementierte, dachte ich, es wäre längerer Code, aber als ich es implementierte, war es unerwartet kurz.

Ich werde den ganzen Code zusammenstellen. (Ich denke, es wäre schön, es auf Github zu setzen) Sie sollten es kopieren und verwenden können. Wenn Sie eine Fehlermeldung erhalten, teilen Sie uns dies bitte in den Kommentaren mit.

import itertools
import math

n = int(input())

seq = [str(i+1) for i in range(n)]

All_set = []
for i in range(n): 
    comb = list(itertools.combinations(seq,i+1))
    All_set.extend(comb)

new_All_set = ['0']
for i in range(len(All_set)): 
    s=""
    a = All_set[i]
    for j in a:
        s += j
    new_All_set.append(s)
    
zero_set = list(0 for _ in range(len(new_All_set))) 

S = new_All_set
V = zero_set

for i in range(len(new_All_set)):
    inp = (input().split())
    if inp[0] in S:
        position = S.index(inp[0])
        V[position] = int(inp[1])
    if inp[0] == "ZERO":
        break

sv = []
for i in range(n):
    res = 0
    i_in = [s for s in S if str(i+1) in s]
    i_not_in = [s for s in S if str(i+1) not in s]
    for j in range(len(i_in)):
        res += math.factorial(len(i_in[j])-1) * math.factorial(n-len(i_in[j])) / math.factorial(n) \
        * (V[S.index(i_in[j])] - V[S.index(i_not_in[j])])
    sv.append(["player"+str(i+1) ,res])
print(sv)

Löse das Problem tatsächlich

Obwohl dies ein Standard ist, ermitteln wir den Scherspielwert in einem Mehrheitsspiel mit drei Spielern. (Siehe S.173 der Übungsspieltheorie)

Die Anzahl der Spieler beträgt drei. Die Bindungswerte für jede Bindung sind wie folgt.

v(123) = v(12) = v(13) = v(23) = 1 \\
v(1) = v(2) = v(3) = 0

Um die Eingabe zu diesem Zeitpunkt zusammenzufassen

Es sieht aus wie. Das Berechnungsergebnis ist wie folgt.

[['player1', 0.3333333333333333], ['player2', 0.3333333333333333], ['player3', 0.3333333333333333]]

Der Scherspielwert jedes Spielers ist richtig auf $ \ frac {1} {3} $ eingestellt. Das ist alles für diesen Artikel. Wenn Sie Fehler oder Probleme haben, melden Sie diese bitte in den Kommentaren.

Berechnung des Scherspielwerts in Python