Créez une application de gestion automatique des notes pour la salle privée Tenho avec le bot LINE et la partie Python ③

introduction

Cette fois, j'ai ajouté la fonction __Rating __ à l'application de gestion automatique des notes de Tenho créée dans le post suivant.

• Création d'une application de gestion automatique des notes pour la salle privée Tenho avec le bot LINE et Python (1)
• Créer une application de gestion automatique des notes pour la salle privée Tenho avec le bot LINE et Python (2)

Formule de notation

La notation adopte le format Tenho suivant. Dans Tenho, Rating est également un système de classement complet basé sur le système de classement complet des notes. Dans notre salle privée, nous avons adopté la règle selon laquelle le poids du point de classement est relativement élevé, nous avons donc adopté la note de style Tenho.

• Manuel officiel Tenho

(Extrait partiel ci-dessous)

• Points de classement (10-30) corrigés par la moyenne du même joueur de table --Valeur initiale = R1500
• Plus le R moyen du tableau est élevé, plus l'augmentation est importante. (Fluctuation du taux) = (correction du numéro de correspondance) x (résultat de la correspondance + valeur de correction) x (coefficient de mise à l'échelle) Correction du nombre de correspondances (moins de 400 correspondances): 1-Nombre de correspondances x 0,002 Correction du numéro de match (400 jeux ou plus): 0,2 Résultat du match (bataille à trois): 1ère place +30 2ème place 0 3ème place-30 Valeur de correction: (Tableau moyen R-votre propre R) / 40 Coefficient d'échelle (bataille de rang): 1.0

Si votre salle privée a une règle qui met l'accent sur les scores bruts sur les scores de classement, elle peut être plus corrélée avec les notes si vous mettez l'accent sur d'autres formules d'évaluation. Les sites suivants calculent la notation de M Leaguer en utilisant trois types de formules, veuillez donc vous y référer.

• J'ai calculé le classement des taux de M Leaguer avec 3 modèles de Tenho, MaruJan et MJ!

la mise en oeuvre

Préambule

import re
import matplotlib.pyplot as plt

Initialisation Rating / R

Initialisez les données de classement par les données initiales (nom du joueur: joueur, R initial: init_rating, nombre initial de villas: init_games) dans ʻinitial_file.txt`. Fondamentalement, R = 1500, jeux = 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

M. A 1500 0
M. B 1500 0
M. C 1500 0
M. D 1500 0

Calcul de R

• Obtenez la valeur de fluctuation R à partir du résultat de la bataille dans le fichier journal et ajoutez la valeur de fluctuation R à la valeur initiale R.
• Les 5 arguments suivants
• Initial R
• Nombre initial de jeux
• R histoire jusqu'à ce point
• Chemin du fichier journal
• Avec ou sans puce
• Les trois valeurs de retour suivantes
• Final R
• Dernier nombre de jeux
• R histoire
• Par exemple, s'il existe plusieurs fichiers journaux, le R total peut être calculé en exécutant cette fonction plusieurs fois.

def calc_rating(initial_rating,initial_games,initial_rating_history,logfile,tip=False):
    with open(logfile) as f:
        lines = f.readlines() #Tout lire jusqu'à la fin du fichier ligne par ligne(Comprend des caractères de saut de ligne)

    rating = initial_rating
    games  = initial_games
    rating_history = initial_rating_history

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

        if len(line) > 10: #Passer les lignes étranges
         
            roomid  = line.split("|")[0]
            time    = line.split("|")[1]
            rools   = line.split("|")[2]
            players = line.split("|")[3]
            
　　　　　　　#Sans félicitations
            if tip == False:
                l = re.split('[ ()]', players)
                player1 = l[1]
                player2 = l[4]
                player3 = l[7]
                
            #S'il y a une fête
            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

            #Correction du numéro de correspondance
            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

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

            #Fluctuation de la cote
            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

Représentation graphique de la fluctuation R

• Le tracé, le tracé à un point du R final et la valeur R finale sont affichés.

def rating_plot(rating_history):

    plt.clf()
    names = {"Monsieur A":"a","Monsieur B":"b","Monsieur C":"c","M. 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 ")

Exécuter (test dans l'environnement local)

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)

Résultat de sortie

• Je joue au mahjong avec 9 personnes, donc 9 graphiques sont affichés.
• Si le R moyen est de 1500 ou moins, il est arrondi, donc la moyenne est supérieure à 1500.
• Au fur et à mesure que le nombre de jeux augmente, la fluctuation de R devient plus petite (elle ne change pas après le 400e match).

Implémentation sur le bot LINE

• Mettez le programme précédent dans le dossier rating et appelez-le à partir du programme de bot de ligne.
• Calcule la note et envoie le graphique lorsqu'il y a eu une action «postback» dans la suite de la dernière fois.
• Si vous gardez la note calculée une fois, il semble que vous n'ayez pas à la calculer à chaque fois, mais comme il semble que vous utiliserez DB etc., j'ai décidé de la calculer à chaque fois pour le moment.
• Puisqu'il existe un fichier journal jusqu'à la saison 3, le R total est calculé.
• Maintenant, vous pouvez toujours voir le dernier (jusqu'à la veille) R de LINE chaque jour.

tenhoulinebot.py

(Omission)
    import download4
    import rating.calc_rating as cr
(Omission)
    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.

Le mahjong de cette saison est en très bon état. Une personne gagne. J'aimerais gagner le championnat tel quel. J'aimerais essayer l'analyse des scores de Tenho, mais le format mjlog (xml) est difficile. .. .. S'il vous plaît, faites-moi savoir. .. ..