Merge branch 'main' of https://huggingface.co/datasets/GEM/RotoWire_English-German

RotoWire_English-German.py

@@ -18,7 +18,7 @@ import json
 import os
 
 import datasets
-
+import re
 
 # Find for instance the citation on arxiv or on the dataset repo/website
 _CITATION = """\
@@ -48,6 +48,13 @@ _URLs = {
     "test": "test.json"
 }
 
+NUM_PLAYERS = 13
+player_line = "<PLAYER> %s <TEAM> %s <POS> %s <RANK> %s <MIN> %d <PTS> %d <FG> %d %d %d <FG3> %d %d %d " \
+              "<FT> %d %d %d <REB> %d <AST> %d <STL> %s " \
+              "<BLK> %d <DREB> %d <OREB> %d <TO> %d"
+
+team_line = "%s <TEAM> %s <CITY> %s <TEAM-RESULT> %s <TEAM-PTS> %d <WINS-LOSSES> %d %d <QTRS> %d %d %d %d " \
+            "<TEAM-AST> %d <3PT> %d <TEAM-FG> %d <TEAM-FT> %d <TEAM-REB> %d <TEAM-TO> %d"
 
 class RotowireEnglishGerman(datasets.GeneratorBasedBuilder):
     """Dataset for WNGT2019 shared task on Document-level Generation and Translation."""
@@ -138,7 +145,8 @@ class RotowireEnglishGerman(datasets.GeneratorBasedBuilder):
                 "summary_en": datasets.Sequence(datasets.Value("string")),
                 "sentence_end_index_en": datasets.Sequence(datasets.Value("int32")),
                 "summary_de": datasets.Sequence(datasets.Value("string")),
-                "sentence_end_index_de": datasets.Sequence(datasets.Value("int32"))
+                "sentence_end_index_de": datasets.Sequence(datasets.Value("int32")),
+                "linearized_input": datasets.Value("string")
             }
         )
         return datasets.DatasetInfo(
@@ -194,6 +202,270 @@ class RotowireEnglishGerman(datasets.GeneratorBasedBuilder):
             ),
         ]
 
+    def handle_na(self, value):
+        return "0" if value == "N/A" else value
+
+    def tokenize_initials(self, value):
+        attrib_value = re.sub(r"(\w)\.(\w)\.", r"\g<1>. \g<2>.", value)
+        return attrib_value
+
+    def sort_points(self, entry):
+        home_team_map = {}
+        vis_team_map = {}
+        bs = entry["box_score"]
+        nplayers = 0
+        for k, v in bs["PTS"].items():
+            nplayers += 1
+
+        num_home, num_vis = 0, 0
+        home_pts = []
+        vis_pts = []
+        for i in range(nplayers):
+            player_city = entry["box_score"]["TEAM_CITY"][str(i)]
+            player_name = bs["PLAYER_NAME"][str(i)]
+            if player_city == entry["home_city"]:
+                if num_home < NUM_PLAYERS:
+                    home_team_map[player_name] = bs["PTS"][str(i)]
+                    if bs["PTS"][str(i)] != "N/A":
+                        home_pts.append(int(bs["PTS"][str(i)]))
+                    num_home += 1
+            else:
+                if num_vis < NUM_PLAYERS:
+                    vis_team_map[player_name] = bs["PTS"][str(i)]
+                    if bs["PTS"][str(i)] != "N/A":
+                        vis_pts.append(int(bs["PTS"][str(i)]))
+                    num_vis += 1
+        if entry["home_city"] == entry["vis_city"] and entry["home_city"] == "Los Angeles":
+            num_home, num_vis = 0, 0
+            for i in range(nplayers):
+                player_name = bs["PLAYER_NAME"][str(i)]
+                if num_vis < NUM_PLAYERS:
+                    vis_team_map[player_name] = bs["PTS"][str(i)]
+                    if bs["PTS"][str(i)] != "N/A":
+                        vis_pts.append(int(bs["PTS"][str(i)]))
+                    num_vis += 1
+                elif num_home < NUM_PLAYERS:
+                    home_team_map[player_name] = bs["PTS"][str(i)]
+                    if bs["PTS"][str(i)] != "N/A":
+                        home_pts.append(int(bs["PTS"][str(i)]))
+                    num_home += 1
+        home_seq = sorted(home_pts, reverse=True)
+        vis_seq = sorted(vis_pts, reverse=True)
+        return home_team_map, vis_team_map, home_seq, vis_seq
+
+    def sort_player_and_points(self, entry):
+        bs = entry["box_score"]
+        nplayers = 0
+        for k, v in bs["PTS"].items():
+            nplayers += 1
+
+        num_home, num_vis = 0, 0
+        home_pts = []
+        vis_pts = []
+        for i in range(nplayers):
+            player_city = entry["box_score"]["TEAM_CITY"][str(i)]
+            player_name = bs["PLAYER_NAME"][str(i)]
+            if player_city == entry["home_city"]:
+                if num_home < NUM_PLAYERS:
+                    if bs["PTS"][str(i)] != "N/A":
+                        home_pts.append((player_name, int(bs["PTS"][str(i)])))
+                    else:
+                        home_pts.append((player_name, -1))
+                    num_home += 1
+            else:
+                if num_vis < NUM_PLAYERS:
+                    if bs["PTS"][str(i)] != "N/A":
+                        vis_pts.append((player_name, int(bs["PTS"][str(i)])))
+                    else:
+                        vis_pts.append((player_name, -1))
+                    num_vis += 1
+        if entry["home_city"] == entry["vis_city"] and entry["home_city"] == "Los Angeles":
+            num_home, num_vis = 0, 0
+            for i in range(nplayers):
+                player_name = bs["PLAYER_NAME"][str(i)]
+                if num_vis < NUM_PLAYERS:
+                    if bs["PTS"][str(i)] != "N/A":
+                        vis_pts.append((player_name, int(bs["PTS"][str(i)])))
+                    else:
+                        vis_pts.append((player_name, -1))
+                    num_vis += 1
+                elif num_home < NUM_PLAYERS:
+                    if bs["PTS"][str(i)] != "N/A":
+                        home_pts.append((player_name, int(bs["PTS"][str(i)])))
+                    else:
+                        home_pts.append((player_name, -1))
+                    num_home += 1
+        home_seq = sorted(home_pts, key=lambda x: -x[1])
+        vis_seq = sorted(vis_pts, key=lambda x: -x[1])
+        return home_seq, vis_seq
+
+    def get_players(self, entry):
+        player_team_map = {}
+        bs = entry["box_score"]
+        nplayers = 0
+        home_players, vis_players = [], []
+        for k, v in entry["box_score"]["PTS"].items():
+            nplayers += 1
+
+        num_home, num_vis = 0, 0
+        for i in range(nplayers):
+            player_city = entry["box_score"]["TEAM_CITY"][str(i)]
+            player_name = bs["PLAYER_NAME"][str(i)]
+            second_name = bs["SECOND_NAME"][str(i)]
+            first_name = bs["FIRST_NAME"][str(i)]
+            if player_city == entry["home_city"]:
+                if len(home_players) < NUM_PLAYERS:
+                    home_players.append((player_name, second_name,
+                                         first_name))
+                    player_team_map[player_name] = " ".join(
+                        [player_city, entry["home_line"]["TEAM-NAME"]])
+                    num_home += 1
+            else:
+                if len(vis_players) < NUM_PLAYERS:
+                    vis_players.append((player_name, second_name,
+                                        first_name))
+                    player_team_map[player_name] = " ".join(
+                        [player_city, entry["vis_line"]["TEAM-NAME"]])
+                    num_vis += 1
+
+        if entry["home_city"] == entry["vis_city"] and entry["home_city"] == "Los Angeles":
+            home_players, vis_players = [], []
+            num_home, num_vis = 0, 0
+            for i in range(nplayers):
+                player_name = bs["PLAYER_NAME"][str(i)]
+                second_name = bs["SECOND_NAME"][str(i)]
+                first_name = bs["FIRST_NAME"][str(i)]
+                if len(vis_players) < NUM_PLAYERS:
+                    vis_players.append((player_name, second_name,
+                                        first_name))
+                    player_team_map[player_name] = " ".join(
+                        ["Los Angeles", entry["vis_line"]["TEAM-NAME"]])
+                    num_vis += 1
+                elif len(home_players) < NUM_PLAYERS:
+                    home_players.append((player_name, second_name,
+                                         first_name))
+                    player_team_map[player_name] = " ".join(
+                        ["Los Angeles", entry["home_line"]["TEAM-NAME"]])
+                    num_home += 1
+
+        players = []
+        for ii, player_list in enumerate([home_players, vis_players]):
+            for j in range(NUM_PLAYERS):
+                players.append(player_list[j] if j < len(player_list) else ("N/A", "N/A", "N/A"))
+        return players, player_team_map
+
+    def get_result_player(self, player_name, home_name, vis_name, home_won, player_team_map):
+        if player_team_map[player_name] == home_name:
+            result = "won" if home_won else "lost"
+        elif player_team_map[player_name] == vis_name:
+            result = "lost" if home_won else "won"
+        else:
+            assert False
+        return result
+
+    def get_box_score(self, entry):
+        box_score_ = entry["box_score"]
+        if int(entry["home_line"]["TEAM-PTS"]) > int(entry["vis_line"]["TEAM-PTS"]):
+            home_won = True
+        else:
+            home_won = False
+        descs = []
+        desc = []
+        if home_won:
+            home_line = self.get_team_line(entry["home_line"], "won", "home")
+            vis_line = self.get_team_line(entry["vis_line"], "lost", "vis")
+        else:
+            home_line = self.get_team_line(entry["home_line"], "lost", "home")
+            vis_line = self.get_team_line(entry["vis_line"], "won", "vis")
+        descs.append(home_line)
+        descs.append(vis_line)
+        players_list, player_team_map = self.get_players(entry)
+        home_team_map, vis_team_map, home_player_pts, vis_player_pts = self.sort_points(entry)
+        home_player_seq, vis_player_seq = self.sort_player_and_points(entry)
+        desc = []
+        for player_name, _ in home_player_seq + vis_player_seq:
+            if player_name == "N/A":
+                continue
+            result = self.get_result_player(player_name, entry["home_city"] + " " + entry["home_line"]["TEAM-NAME"],
+                                       entry["vis_city"] + " " + entry["vis_line"]["TEAM-NAME"], home_won,
+                                       player_team_map)
+            player_line = self.get_player_line(box_score_, player_name, player_team_map, home_player_pts,
+                                          vis_player_pts, home_team_map, vis_team_map, result)
+            desc.append(player_line)
+        descs.extend(desc)
+        return descs
+
+    def get_rank(self, player_name, home_seq, vis_seq, home_team_map, vis_team_map, result):
+        if player_name in home_team_map:
+            if home_team_map[player_name] == 'N/A':
+                rank = 'HOME-DIDNTPLAY'
+            else:
+                rank = 'HOME-' + str(home_seq.index(int(home_team_map[player_name])))
+        elif player_name in vis_team_map:
+            if vis_team_map[player_name] == 'N/A':
+                rank = 'VIS-DIDNTPLAY'
+            else:
+                rank = 'VIS-' + str(vis_seq.index(int(vis_team_map[player_name])))
+        else:
+            print("player_name", player_name)
+            assert False
+        return rank
+
+    def get_player_line(self, bs, input_player_name, player_team_map, home_player_pts, vis_player_pts, home_team_map,
+                        vis_team_map, result):
+        rank = self.get_rank(input_player_name, home_player_pts, vis_player_pts, home_team_map, vis_team_map, result)
+        player_names = list(bs["PLAYER_NAME"].items())
+        player_found = False
+        player_tup = None
+        for (pid, name) in player_names:
+            if name == input_player_name:
+                player_tup = (self.tokenize_initials(name), player_team_map[input_player_name],
+                              bs["START_POSITION"][pid],
+                              rank,
+                              int(self.handle_na(bs["MIN"][pid])),
+                              int(self.handle_na(bs["PTS"][pid])),
+                              int(self.handle_na(bs["FGM"][pid])),
+                              int(self.handle_na(bs["FGA"][pid])), int(self.handle_na(bs["FG_PCT"][pid])),
+                              int(self.handle_na(bs["FG3M"][pid])), int(self.handle_na(bs["FG3A"][pid])),
+                              int(self.handle_na(bs["FG3_PCT"][pid])),
+                              int(self.handle_na(bs["FTM"][pid])), int(self.handle_na(bs["FTA"][pid])),
+                              int(self.handle_na(bs["FT_PCT"][pid])),
+                              int(self.handle_na(bs["REB"][pid])), int(self.handle_na(bs["AST"][pid])),
+                              int(self.handle_na(bs["STL"][pid])),
+                              int(self.handle_na(bs["BLK"][pid])), int(self.handle_na(bs["DREB"][pid])),
+                              int(self.handle_na(bs["OREB"][pid])), int(self.handle_na(bs["TO"][pid])))
+                player_found = True
+                break
+        assert player_found
+        return player_line % (player_tup)
+
+    def get_team_line(self, line, result, type):
+        city = line["TEAM-CITY"]
+        name = line["TEAM-NAME"]
+        wins = int(line["TEAM-WINS"])
+        losses = int(line["TEAM-LOSSES"])
+        pts = int(line["TEAM-PTS"])
+        ast = int(line["TEAM-AST"])
+        three_pointers_pct = int(line["TEAM-FG3_PCT"])
+        field_goals_pct = int(line["TEAM-FG_PCT"])
+        free_throws_pct = int(line["TEAM-FT_PCT"])
+        pts_qtr1 = int(line["TEAM-PTS_QTR1"])
+        pts_qtr2 = int(line["TEAM-PTS_QTR2"])
+        pts_qtr3 = int(line["TEAM-PTS_QTR3"])
+        pts_qtr4 = int(line["TEAM-PTS_QTR4"])
+        reb = int(line["TEAM-REB"])
+        tov = int(line["TEAM-TOV"])
+        updated_type = "<" + type.upper() + ">"
+        team_tup = (updated_type, name, city, result, pts, wins, losses, pts_qtr1, pts_qtr2, pts_qtr3, pts_qtr4, ast,
+                    three_pointers_pct, field_goals_pct, free_throws_pct, reb, tov)
+        return team_line % (team_tup)
+
+    def linearize_input(self, entry):
+        output = self.get_box_score(entry)
+        linearized_input = " ".join(output)
+        linearized_input = linearized_input.replace("  ", " ")
+        return linearized_input
+    
     def _generate_examples(
         self, filepath, split  # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
     ):
@@ -204,4 +476,5 @@ class RotowireEnglishGerman(datasets.GeneratorBasedBuilder):
         with open(filepath, encoding="utf-8") as f:
             all_data = json.load(f)
             for id_, data in enumerate(all_data):
+                data['linearized_input'] = self.linearize_input(data)
                 yield id_, data