(Python) Ich habe versucht, 1 Million Hände zu analysieren ~ Ich habe versucht, die Anzahl der AA ~ zu schätzen

Vielen Dank für das Surfen. Es ist pbird gelb.

Dieses Mal schätzte ich die Anzahl der AA-Auftritte auf 1 Million Hände. Insbesondere schätzen wir, wie wahrscheinlich und wie viel AA für eine unbekannte 2000-Hand erscheinen wird, die Sie in Zukunft spielen werden. Das Schätzverfahren ist wie folgt.

① Sammeln Sie die Hände und erstellen Sie ein Histogramm ② Testen Sie, ob die aggregierten Hände normal sind ③ Ermitteln Sie den Durchschnittswert und den Standardabweichungswert ④ Schätzen Sie die Anzahl der AA-Vorkommen mit einer Genauigkeit von 95%

In Bezug auf die oben genannten Inhalte und die technischen Begriffe, die danach erscheinen werden, sind die folgenden Bücher sehr leicht zu verstehen, daher werde ich sie veröffentlichen. ・ "Vollständige Einführungsstatistik zum Selbststudium Kindle-Version" Hiroyuki Kojima (Autor) https://amzn.to/3mSPpqf

Unten finden Sie ein Histogramm, das die Schlussfolgerungen zusammenfasst. Im Histogramm dieses Artikels zeigt die vertikale Achse den integrierten Wert und die horizontale Achse zeigt, wie oft AA in 2000 Händen aufgetreten ist.

■ Was ist ein Histogramm? Ein Histogramm ist einfach ein "Diagramm aggregierter Daten". Nehmen Sie die obige Abbildung als Beispiel ・ Die Häufigkeit, mit der AA alle 2000 Hände auftrat, betrug das 8-fache (horizontale Achse), das 72-fache (vertikale Achse) von 1 Million Händen. ・ Die Häufigkeit, mit der AA alle 2000 Hände auftrat, war zweimal (horizontale Achse), jedoch einmal in 1 Million Händen (vertikale Achse). Und so weiter.

■ Was ist ein SW-Test? Es gibt verschiedene Testmethoden für die Normalität, aber dieses Mal werden wir den SW-Test verwenden. Der SW-Test ist eine Methode, um zu überprüfen, ob die aggregierten Daten in der ursprünglichen Datengruppe (= Grundgesamtheit) normal sind. Mit Normalität können verschiedene Gesetze angewendet werden. Mit diesen Regeln kann die Anzahl der AA-Vorkommen geschätzt werden.

Im SW-Test wird der p-Wert verwendet, um die Normalität zu beurteilen. Der p-Wert ist ein Wert, der die Wahrscheinlichkeit ausdrückt, dass Daten wie aggregierte Daten verteilt werden, wenn Daten zufällig aus der Grundgesamtheit ausgewählt und verteilt werden, vorausgesetzt, die Grundgesamtheit weist Normalität auf. Wenn die Verteilungswahrscheinlichkeit weniger als 5% beträgt, ist sie im Allgemeinen zu gering und es wird beurteilt, dass die Bevölkerung überhaupt keine Normalitätsregeln hat (= die Bevölkerung hat keine Normalität). .. In der obigen Abbildung beträgt der p-Wert (P-Wert) 0,08> 0,05 (= 5%), so dass gesagt werden kann, dass es eine marginale Normalität gibt.

■ Durchschnittswert und Standardabweichungswert In der obigen Abbildung ・ Durchschnitt → Durchschnitt (μ) ・ Abweichung → Standardabweichung (σ) Anwendbar.

■ Schätzmethode mit 95% Genauigkeit Sei μ der Durchschnittswert der aggregierten Daten und σ der Standardabweichungswert. Es besteht eine 95% ige Wahrscheinlichkeit, dass die Anzahl der AA-Vorkommen innerhalb von "μ-1,96σ ≤ x ≤ μ + 1,96σ" liegt.

Also ** "Wenn Sie 2000 Hände spielen, erscheint AA 3,37-mal oder mehr und 15,29-mal oder weniger mit einer 95% igen Chance." ** Es wird sein.

Da die Schätzung auf den Daten von 1 Million Händen basiert, liegt ein Fehler im obigen Schätzwert vor. Wenn die Daten zunehmen und sich die Mittel- und Standardabweichungswerte dem Populationsmittelwert und den Populationsstandardabweichungswerten nähern, sind auch die geschätzten Werte genau.

• Diese Zahl ist jedoch ein Wert, der nur Gott bekannt ist.

Im Fall von KK ist es übrigens wie folgt. Da der P-Wert = 0,03 <0,05 ist, wird die Annahme verworfen und die Population hat keine Normalität. In diesem Fall weisen die aggregierten Daten keine Normalität auf, sodass eine Schätzung mit einer Genauigkeit von 95% nicht möglich ist.

Wenn sich jedoch die Anzahl der Hände erhöht, erhöht sich der P-Wert und die Daten sind normal.

Im Fall von QQ gibt es Normalität ** "Wenn Sie 2000 Hände spielen, erscheint QQ 3,40-mal oder mehr und 14,54-mal oder weniger mit einer 95% igen Chance" **.

Warum ist KK übrigens nicht regelmäßig? Was ist der Unterschied zu AA- oder QQ-Histogrammen? Ich denke, einige Leute sagen das.

···Ich stimme mit Ihnen ein! !! !!

Es ist schlecht, dass der p-Wert um den numerischen Wert an der Grenze der Grenze geschätzt wird. Dieses Problem kann gelöst werden, indem alle 2000 Hände auf 1000 Hände gewechselt werden. Dies ist jedoch ein Problem, und da der Wert auf der horizontalen Achse nur 0 oder mehr beträgt, ist es nicht möglich, eine ordnungsgemäße Analyse durchzuführen ...

Der Punkt ist, dass 1 Million Hände zu wenig lol ist

Dies ist jedoch sehr praktisch, da solche komplizierten Berechnungen mit Python im Handumdrehen durchgeführt werden können. Ich werde den Quellcode behalten, also benutze ihn bitte auch !!

Tatsächlich ist der Inhalt des SW-Tests nicht sehr gut verstanden. In Python können Sie in nur einer Zeile berechnen. Selbst wenn Sie wissen, welche Art von numerischem Wert Sie erhalten können, ist der Berechnungsprozess schwer zu verstehen. Wenn Sie Bücher haben, die anhand konkreter Beispiele erklärt werden, wäre ich Ihnen dankbar, wenn Sie mich wissen lassen könnten!

Unten ist der Quellcode. Das Programm ist ein absoluter Anfänger. Wenn Sie also Ideen haben, wie Sie besseren Code schreiben können, lassen Sie es uns bitte wissen! !!

pokermain.py

from holdcards import Holdcards 
from plotgraph import Plotgraph
import os
import glob
import re

path='Schreiben Sie den Pfad hier'
hand = "AA"  #Beschreiben Sie die Hand, die Sie nachschlagen möchten
count = 2000 #Beschreiben Sie jede Hand, die Sie überprüfen möchten


num = lambda val : int(re.sub("\\D", "", val))
filelist = sorted(glob.glob(os.path.join(path,"*.txt"),recursive=True),key = num)
totcards = []
graphdata = []
countdata = []
counthands = []
for item in filelist:
    print(item)
    with open(item) as f:
        data = f.readlines()
        card = Holdcards()
        h_cards = card.find_holdcards(data)
        totcards += h_cards

i = 0
while len(totcards[count*i:count*(i+1)]) == count:
    graphdata.append(totcards[count*i:count*(i+1)])
    i += 1

for item in graphdata:
    countdata.append(item.count(hand))

graph= Plotgraph()

graph.writehist(countdata,hand,count,len(graphdata)*count)  #SW-Test-Normalisierung

holdcards.py

class Holdcards:
       def __init__(self):
              self.trump={"A":"14","K":"13","Q":"12","J":"11","T":"10","9":"9","8":"8","7":"7","6":"6","5":"5","4":"4","3":"3","2":"2"}
              self.r_trump={"14":"A","13":"K","12":"Q","11":"J","10":"T","9":"9","8":"8","7":"7","6":"6","5":"5","4":"4","3":"3","2":"2"}
              self.hands = 0
              self.tothands = 0
              self.handlist = []


       def find_holdcards(self,data):
              holdcards = []
              for item in data:
                     if 'Dealt to' in item:
                            item = item[-7:-2]
                            if item[1] == item[4]:
                                   if int(self.trump.get(item[0])) > int(self.trump.get(item[3])):
                                          item = item[0] + item[3] + 's'
                                   else:
                                          item = item[3] + item[0] + 's'
                            else:
                                   if int(self.trump.get(item[0])) > int(self.trump.get(item[3])):
                                          item = item[0] + item[3] + 'o'
                                   elif item[0] == item[3]:
                                          item = item[0] + item[3]
                                   else:
                                          item = item[3] + item[0] + 'o'
                            
                            holdcards.append(item)
              return holdcards

plotgraph.py

import numpy as np
import pandas as pd
import scipy.stats as st
import math                        
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker 
import matplotlib.transforms as ts 

class Plotgraph:
       def __init__(self):
              pass

       def writehist(self,countdata,hand,count,tothands):#Mittelwert mu, Standardabweichung sig, Anzahl normaler Zufallszahlen n

              df = pd.DataFrame( {'p1':countdata} )
              target = 'p1'  #Spalten, die im Datenrahmen gezeichnet werden sollen
              # (1)Statistische Verarbeitung
              mu  = round(df[target].mean(),2)  #durchschnittlich
              sig = round(df[target].std(ddof=0),2)#Standardabweichung: ddof(Freiheitsgrad)=0
              print(f'■ Durchschnitt:{df[target].mean():.2f},Standardabweichung:{df[target].std(ddof=0):.2f}')
              ci1, ci2 = (None, None)

              #Diagrammzeichnungsparameter
              x_min = round(mu - 3*sig)
              x_max = round(mu + 3*sig)  #Bewertungsbereich für die Darstellung (untere und obere Grenze)
              j = 10                  #Schrittweite der Y-Achse (Frequenz)
              k = 1                   #Klasse
              bins = int((x_max - x_min)/k)            #Anzahl der Abschnitte(x_max-x_min)/k  (100-40)/5->12
              d = 0.001

              #Zeichenprozess von hier
              plt.figure(dpi=96)
              plt.xlim(x_min,x_max)
              hist_data = plt.hist(df[target], bins=bins, color='tab:cyan', range=(x_min, x_max), rwidth=0.9)
              n   = len(hist_data[0])    #Probengröße
              plt.title("hand = "+hand+" , totalhands = "+str(tothands))

              # (2)Zeichnen eines Histogramms
              plt.gca().set_xticks(np.arange(x_min,x_max-k+d, k))

              #Normalitätstest (Signifikanzniveau 5)%）
              _, p = st.shapiro(hist_data[0])
              print(hist_data[0])
              print(st.shapiro(hist_data[0]))
              if p >= 0.05 :
                     print(f'  - p={p:.2f} ( p>=0.05 )Und man kann sagen, dass die Bevölkerung Normalität hat')
                     U2 = df[target].var(ddof=1)  #Populationsvarianzschätzung (unvoreingenommene Varianz)
                     print(U2)
                     DF = n-1                     #Freiheitsgrad
                     SE = math.sqrt(U2/n)         #Standart Fehler
                     print(SE)
                     ci1,ci2 = st.t.interval( alpha=0.95, loc=mu, scale=SE, df=DF )
              else:
                     print(f'  ※ p={p:.2f} ( p<0.05 )Und die Bevölkerung kann nicht als normal bezeichnet werden')


              # (3)Ungefähre Kurve unter Annahme einer Normalverteilung
              sig = df[target].std(ddof=1)  #Unvoreingenommene Standardabweichung: ddof(Freiheitsgrad)=1
              nx = np.linspace(x_min, x_max+d, 150) #150 Abteilungen
              ny = st.norm.pdf(nx,mu,sig) * k * len(df[target])
              plt.plot( nx , ny, color='tab:blue', linewidth=1.5, linestyle='--')

              # (4)X-Achsen-Skalierungs- / Beschriftungseinstellung
              plt.xlabel('total"'+str(hand)+'"/'+str(count)+'hands',fontsize=12)
              plt.gca().set_xticks(np.arange(x_min,x_max+d, k))
              # (5)Skalierungs- / Beschriftungseinstellung der Y-Achse
              y_max = max(hist_data[0].max(), st.norm.pdf(mu,mu,sig) * k * len(df[target]))
              y_max = int(((y_max//j)+1)*j) #Das kleinste Vielfache von j, das größer als die maximale Frequenz ist
              plt.ylim(0,y_max)
              plt.gca().set_yticks( range(0,y_max+1,j) )
              plt.ylabel('Accumulation',fontsize=12)

              # (6)Textausgabe der Durchschnittspunktzahl und der Standardabweichung
              tx = 0.03 #Zur Einstellung der Zeichenausgabeposition
              ty = 0.91 #Zur Einstellung der Zeichenausgabeposition
              tt = 0.08 #Zur Einstellung der Zeichenausgabeposition
              tp = dict( horizontalalignment='left',verticalalignment='bottom',
                     transform=plt.gca().transAxes, fontsize=11 )
              plt.text( tx, ty, f'average {mu:.2f}', **tp)
              plt.text( tx, ty-tt, f'deviation {sig:.2f}', **tp)
              plt.text( tx, ty-tt-tt, f'P-value {p:.2f}', **tp)
              plt.vlines( mu, 0, y_max, color='black', linewidth=1 )


              plt.show()