Einführung

Dieses Mal habe ich der im folgenden Beitrag erstellten automatischen Notenverwaltungs-App von Tenho die Bewertungsfunktion __ hinzugefügt.

Erstellen einer automatischen Klassenverwaltungs-App für den privaten Raum von Tenho mit LINE-Bot und Python (1)
Erstellen Sie eine automatische Klassenverwaltungs-App für den Tenho-Privatraum mit LINE-Bot und Python (2)

Bewertungsformel

Die Bewertung nimmt das folgende Tenho-Format an. In Tenho ist Rating auch ein vollständiges Rangsystem, das auf dem vollständigen Rangsystem der Noten basiert. In unserem privaten Raum haben wir die Regel übernommen, dass das Gewicht des Ranglistenpunkts relativ hoch ist, und haben daher die Bewertung im Tenho-Stil übernommen.

Tenho Official Manual

(Teilauszug unten)

Ranglistenpunkte (10-30) korrigiert um den Durchschnitt desselben Tischspielers

Anfangswert = R1500

Je höher das durchschnittliche R der Tabelle ist, desto größer ist der Anstieg. (Ratenschwankung) = (Übereinstimmungszahlkorrektur) x (Übereinstimmungsergebnis + Korrekturwert) x (Skalierungskoeffizient) Korrektur der Übereinstimmungszahl (weniger als 400 Übereinstimmungen): 1 - Anzahl der Übereinstimmungen x 0,002 Spielnummernkorrektur (400 Spiele oder mehr): 0,2 Spielergebnis (Drei-Spieler-Kampf): 1. Platz +30 2. Platz 0 3. Platz-30 Korrekturwert: (Tabellenmittelwert R - Ihr eigenes R) / 40 Skalierungskoeffizient (Rangkampf): 1,0

Wenn in Ihrem privaten Raum eine Regel gilt, bei der die Rohwerte gegenüber den Ranglistenwerten hervorgehoben werden, kann dies zu einer stärkeren Korrelation mit den Noten führen, wenn Sie andere Bewertungsformeln hervorheben. Auf der folgenden Website wird die Bewertung von M Leaguer anhand von drei Formeltypen berechnet. Bitte beziehen Sie sich darauf.

Ich habe das Ratenranking von M Leaguer mit 3 Mustern von Tenho, MaruJan und MJ berechnet!

Implementierung

Präambel

import re
import matplotlib.pyplot as plt

Rating / R-Initialisierung

Die Bewertungsdaten werden durch die Anfangsdaten (Spielername: Spieler, Anfangs-R: Init_Rating, Anfangsanzahl der Villen: Init_Games) in initial_file.txt initialisiert. Grundsätzlich ist R = 1500, Spiele = 0.

`calc_rating.py`



def initialize_rating(initial_file):
    
    with open(initial_file) as f:
        init_ratings = f.readlines() 

    rating = {}
    games  = {}
    rating_history = {}
    
    for l in init_ratings:
        player      = l.split()[0]
        init_rating = l.split()[1] 
        init_games  = l.split()[2]
        rating[player] = float(init_rating) 
        games[player]  = int(init_games)
        rating_history[player] = [float(init_rating)]
        print(games)
    
    return rating,games,rating_history

`initial_file.txt`


Herr A 1500 0
Herr B 1500 0
Herr C 1500 0
Herr D 1500 0

Berechnung von R.

Ermitteln Sie den R-Fluktuationswert aus dem Kampfergebnis in der Protokolldatei und addieren Sie den R-Fluktuationswert zum anfänglichen R.
Die folgenden 5 Argumente
Anfangs-R
Anfangsanzahl der Spiele
R Geschichte bis zu diesem Punkt
Protokolldateipfad
Mit oder ohne Chip
Die folgenden drei Rückgabewerte
Final R.
Letzte Anzahl von Spielen
R Geschichte
Wenn beispielsweise mehrere Protokolldateien vorhanden sind, kann das Gesamt-R berechnet werden, indem diese Funktion mehrmals ausgeführt wird.

def calc_rating(initial_rating,initial_games,initial_rating_history,logfile,tip=False):
    with open(logfile) as f:
        lines = f.readlines() #Lesen Sie alles bis zum Ende der Datei Zeile für Zeile(Enthält Zeilenvorschubzeichen)

    rating = initial_rating
    games  = initial_games
    rating_history = initial_rating_history

    for line in lines[1:]:
        # print(games)

        if len(line) > 10: #Überspringen Sie seltsame Zeilen
         
            roomid  = line.split("|")[0]
            time    = line.split("|")[1]
            rools   = line.split("|")[2]
            players = line.split("|")[3]
            
　　　　　　　#Ohne Glückwünsche
            if tip == False:
                l = re.split('[ ()]', players)
                player1 = l[1]
                player2 = l[4]
                player3 = l[7]
                
            #Wenn es eine Feier gibt
            if tip == True:
                l = re.split('[ (,)]', players)
                player1 = l[1]
                player2 = l[5]
                player3 = l[9]

            rate_average = (rating[player1]+rating[player2]+rating[player3])/3.0
            rate_average = round(rate_average,3)
            if rate_average < 1500.0:
                rate_average = 1500.0

            #Korrektur der Übereinstimmungsnummer
            if games[player1] < 400:
                games_correction1 = 1.0 - games[player1]*0.002
            if games[player1] >= 400:
                games_correction1 = 0.2
            if games[player2] < 400:
                games_correction2 = 1.0 - games[player2]*0.002
            if games[player2] >= 400:
                games_correction2 = 0.2
            if games[player3] < 400:
                games_correction3 = 1.0 - games[player3]*0.002
            if games[player3] >= 400:
                games_correction3 = 0.2

            #Durchschnittliche R-Korrektur
            averageR_correction1 = (rate_average - rating[player1])/40.0
            averageR_correction2 = (rate_average - rating[player2])/40.0
            averageR_correction3 = (rate_average - rating[player3])/40.0

            #Bewertungsschwankungen
            rate_delta1 = round(games_correction1 * ( 30.0  + averageR_correction1 ) * 1.0, 3) # 1st
            rate_delta2 = round(games_correction2 * ( 0.0   + averageR_correction2 ) * 1.0, 3) # 2nd
            rate_delta3 = round(games_correction3 * ( -30.0 + averageR_correction3 ) * 1.0, 3) # 3rd
            print(rate_delta1,rate_delta2,rate_delta3)

            # Rating
            rating[player1] += rate_delta1
            rating[player2] += rate_delta2
            rating[player3] += rate_delta3

            # Rating History
            rating_history[player1].append(rating[player1]) 
            rating_history[player2].append(rating[player2]) 
            rating_history[player3].append(rating[player3])             

            # Games
            games[player1] += 1
            games[player2] += 1
            games[player3] += 1

    return rating,games,rating_history

R-Fluktuation grafisch darstellen

Das Diagramm, das Einpunktdiagramm des endgültigen R und der endgültige R-Wert werden angezeigt.

def rating_plot(rating_history):

    plt.clf()
    names = {"Herr A.":"a","Herr B.":"b","Herr C.":"c","Herr D.":"d"}
    for player in rating_history.keys():
        x = [i for i in range(len(rating_history[player]))]
        y = rating_history[player]
        plt.plot(x,y,linewidth=0.5,alpha=0.5)
        plt.scatter(x[-1],y[-1],label=names[player])
        plt.text(x[-1],y[-1]+5,int(y[-1]))

    plt.legend()
    plt.savefig("rating.png ")

Ausführen (Test in lokaler Umgebung)

if __name__ == "__main__":
    r,g,h = initialize_rating("rating.txt")
    r,g,h = calc_rating(r,g,h,"logvol1.txt",tip=False)
    r,g,h = calc_rating(r,g,h,"logvol2.txt",tip=True)
    r,g,h = calc_rating(r,g,h,"logvol3.txt",tip=True)

    rating_plot(h)

Ausgabeergebnis

Ich spiele Mahjong mit 9 Personen, daher werden 9 Grafiken angezeigt.
Wenn der Durchschnitt R 1500 oder weniger beträgt, wird er aufgerundet, sodass der Durchschnitt größer als 1500 ist.
Mit zunehmender Anzahl von Spielen wird die Fluktuation von R kleiner (sie ändert sich nach dem 400. Spiel nicht).

Implementierung auf LINE Bot

Legen Sie das vorherige Programm in den Ordner "Rating" und rufen Sie es aus dem Line-Bot-Programm auf.
Berechnet die Bewertung und sendet die Grafik, wenn in der Fortsetzung des letzten Males eine "Postback" -Aktion stattgefunden hat.
Wenn Sie die Bewertung einmal berechnet lassen, müssen Sie sie anscheinend nicht jedes Mal berechnen. Da Sie jedoch anscheinend DB usw. verwenden, habe ich beschlossen, sie vorerst jedes Mal zu berechnen.
Da es bis Staffel 3 eine Protokolldatei gibt, wird der Gesamt-R berechnet.
Jetzt können Sie jeden Tag das neueste (bis zum vorherigen Tag) R von LINE sehen.

`tenhoulinebot.py`



(Unterlassung)
    import download4
    import rating.calc_rating as cr
(Unterlassung)
    elif postbackdata == "request_rating":
        download4.download("/logvol1.txt","rating/logvol1.txt")
        download4.download("/logvol2.txt","rating/logvol2.txt")
        download4.download("/logvol3.txt","rating/logvol3.txt")
        
        initial_rating,initial_games,initial_rating_history = cr.initialize_rating("rating/rating.txt")
        r,g,h = cr.calc_rating(initial_rating,initial_games,initial_rating_history,"rating/logvol1.txt",tip=False)
        r,g,h = cr.calc_rating(r,g,h,"rating/logvol2.txt",tip=True)
        r,g,h = cr.calc_rating(r,g,h,"rating/logvol3.txt",tip=True)
        cr.rating_plot(h)

        bucket.upload_file("rating.png ", "rating.png ")
        s3_image_url = s3_client.generate_presigned_url(
            ClientMethod = 'get_object',
            Params       = {'Bucket': aws_s3_bucket, 'Key': "rating.png "},
            ExpiresIn    = 600,
            HttpMethod   = 'GET'
        )

        line_bot_api.reply_message(
            event.reply_token,
            ImageSendMessage(
                original_content_url = s3_image_url,
                preview_image_url    = s3_image_url,
            )
        )
        download4.upload("rating.png ","/rating.png ")

P.S.

Der Mahjong dieser Saison ist in sehr gutem Zustand. Eine Person gewinnt. Ich möchte die Meisterschaft so wie sie ist gewinnen. Ich würde gerne Tenhos Score-Analyse ausprobieren, aber das mjlog-Format (xml) ist schwierig. .. .. Lass es mich wissen, bitte. .. ..

Erstellen Sie eine automatische Klassenverwaltungs-App für Tenho Private Room mit LINE Bot und Python Part ③