Update merged entity link

collect_vocab.py

@@ -0,0 +1,93 @@
+import os, sys
+import nltk
+from collections import Counter
+import pickle
+from datasets import load_dataset
+from tqdm import tqdm
+import csv
+import json
+import re
+
+def tokenize(message):
+    """
+    Text processing: Sentence tokenize, then concatenate the word_tokenize of each sentence. Then lower.
+    :param message:
+    :return:
+    """
+    sentences = nltk.sent_tokenize(message)
+    tokenized = []
+    for sentence in sentences:
+        tokenized += nltk.word_tokenize(sentence)
+    return [word.lower() for word in tokenized]
+
+
+def load_movie_mappings(path):
+    id2name = {}
+    db2id = {}
+
+    with open(path, 'r') as f:
+        reader = csv.reader(f)
+        # remove date from movie name
+        for row in reader:
+            if row[0] != "index":
+                id2name[int(row[0])] = row[1]
+                # id2name[int(row[0])] = row[1]
+                db2id[int(row[2])] = int(row[0])
+
+    del db2id[-1]
+    date_pattern = re.compile(r'\(\d{4}\)')
+
+    # get dataset characteristics
+    db2name = {db: date_pattern.sub('', id2name[id]).strip(" ") for db, id in db2id.items()}
+    n_redial_movies = len(db2id.values())  # number of movies mentioned in ReDial
+    # name2id = {name: int(i) for i, name in id2name.items() if name != ''}
+
+    # print("loaded {} movies from {}".format(len(name2id), path))
+    return id2name, db2name
+
+
+def get_vocab(dataset, db2name):
+    """
+    get the vocabulary from the train data
+    :return: vocabulary
+    """
+    print(f"Loading vocabulary from {dataset} dataset")
+    counter = Counter()
+    # get vocabulary from dialogues
+    datasets = load_dataset(dataset, download_mode="force_redownload")
+    date_pattern = re.compile(r'@(\d+)')
+    for subset in ["train", "validation", "test"]:
+        for conversation in tqdm(datasets[subset]):
+            for message in conversation["messages"]:
+                # remove movie Ids
+                text = tokenize(date_pattern.sub(" ", message))
+                counter.update([word.lower() for word in text])
+    # get vocabulary from movie names
+    for movieId in db2name:
+        tokenized_movie = tokenize(db2name[movieId])
+        counter.update([word.lower() for word in tokenized_movie])
+    # Keep the most common words
+    kept_vocab = counter.most_common(15000)
+    vocab = [x[0] for x in kept_vocab]
+    print("Vocab covers {} word instances over {}".format(
+        sum([x[1] for x in kept_vocab]),
+        sum([counter[x] for x in counter])
+    ))
+    # note: let the <pad> token corresponds to 0
+    vocab = ['<pad>', '<s>', '</s>', '<unk>', '\n'] + vocab
+
+    return vocab
+
+if __name__ == '__main__':
+    import os
+    dataset = 'redial'
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    id2entity, db2name = load_movie_mappings(os.path.join(base_dir, "movies_merged.csv"))
+
+    with open(os.path.join(base_dir, 'id2entity.json'), 'w') as f:
+        json.dump(id2entity, f)
+    # vocab = get_vocab(dataset, db2name)
+    # print("vocab has length:", len(vocab))
+    # with open(os.path.join(base_dir, 'vocab.json'), 'w') as f:
+    #     json.dump(vocab, f)
+    #

extract_name2link.py

@@ -0,0 +1,45 @@
+import json
+import csv
+import re
+
+entityLink2id = json.load(open('entity2id.json'))
+
+reader = csv.reader(open('movies_merged.csv'))
+
+date_pattern = re.compile(r'\(\d+\)')
+
+entity2link = {}
+
+temp1 = "<http://dbpedia.org/resource/{}_(film)>"
+temp2 = "<http://dbpedia.org/resource/{}_({}_film)>"
+temp3 = "<http://dbpedia.org/resource/{}>"
+
+
+for row in reader:
+    if row[0] == 'index':
+        continue
+    entity = row[1].strip('"')
+    match = date_pattern.search(entity)
+    if match:
+        movieName = entity[:match.start()].strip(' ')
+        year = match.group(0)[1:-1]
+    else:
+        movieName = entity.strip(' ')
+        year = ''
+    movieName = movieName.replace(' ', '_')
+    if (t1 := temp1.format(movieName)) in entityLink2id:
+        entity2link[entity] = t1
+    elif (t2 := temp2.format(movieName, year)) in entityLink2id:
+        entity2link[entity] = t2
+    elif (t3 := temp3.format(movieName)) in entityLink2id:
+        entity2link[entity] = t3
+
+
+
+print('entity2link: ', len(entity2link))
+for e, link in entity2link.items():
+    entity2link[e] = link[1:-1]
+json.dump(entity2link, open('entity2link.json', 'w'))
+
+
+

redial.py

@@ -1,15 +1,22 @@
 import json
 import re
 from typing import List
-
+import html
 import datasets
 
+ENTITY = 'entity'
+ENTITY_PATTERN = r'<entity>{}</entity>'
+
 logger = datasets.logging.get_logger(__name__)
 
+
 class RedialConfig(datasets.BuilderConfig):
     """BuilderConfig for ReDIAL."""
 
-    def __init__(self, features, **kwargs):
+    def __init__(self, features,
+                 initiator_prefix='User: ',
+                 respondent_prefix='System: ',
+                 **kwargs):
         """BuilderConfig for ReDIAL.
 
         Args:
@@ -19,6 +26,9 @@ class RedialConfig(datasets.BuilderConfig):
         """
         super().__init__(version=datasets.Version("0.0.1"), **kwargs)
         self.features = features
+        self.initiator_prefix = initiator_prefix
+        self.respondent_prefix = respondent_prefix
+
 
 _URL = "./"
 _URLS = {
@@ -28,11 +38,10 @@ _URLS = {
 }
 
 
-
-
 class ReDIAL(datasets.GeneratorBasedBuilder):
     DEFAULT_CONFIG_NAME = "rec"
     BUILDER_CONFIGS = [
+
         RedialConfig(
             name="SA",
             description="For using the ReDIAL dataset to train sentiment analysis on movies in sentences",
@@ -45,7 +54,21 @@ class ReDIAL(datasets.GeneratorBasedBuilder):
                     datasets.Value("int32"), length=6
                 )
             },
+            # certain information(e.g. movie_occurrences) is model-specific, and we leave it for Dataset.map
         ),
+        # RedialConfig(
+        #     name="SA_debug",
+        #     description="For using the ReDIAL dataset to train sentiment analysis on movies in sentences",
+        #     features={
+        #         "id": datasets.Value("int32"),
+        #         "movieName": datasets.Value("string"),
+        #         "messages": datasets.features.Sequence(datasets.Value("string")),
+        #         "senders": datasets.features.Sequence(datasets.Value("int32")),
+        #         "form": datasets.features.Sequence(
+        #             datasets.Value("int32"), length=6
+        #         )
+        #     },
+        # ),
         RedialConfig(
             name="autorec",
             description="For training autorec model on ReDIAL data",
@@ -63,14 +86,19 @@ class ReDIAL(datasets.GeneratorBasedBuilder):
                 "senders": datasets.features.Sequence(datasets.Value("int32")),
             },
         ),
-
+        RedialConfig(
+            name="formatted",
+            description='Embed all information into a text sequence for each dialog',
+            features={
+                "messages": datasets.features.Sequence(datasets.Value("string")),
+            }
+        )
     ]
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.last_sender = None
 
-
     def _processMessage(self, msg, initialId):
         """
         msg example:     {
@@ -80,13 +108,13 @@ class ReDIAL(datasets.GeneratorBasedBuilder):
           "messageId": 204171
         },
         """
-        res =  {
+        res = {
             "text": msg["text"],
             "sender": 1 if msg["senderWorkerId"] == initialId else -1
         }
         return res
 
-    def _flattenMessages(self, conversation):
+    def _flattenMessages(self, conversation, add_prefix=False):
         messages = []
         senders = []
         for message in conversation["messages"]:
@@ -96,12 +124,15 @@ class ReDIAL(datasets.GeneratorBasedBuilder):
                 messages[-1] += "\n" + text
             else:
                 senders.append(role)
+                if add_prefix:
+                    prefix = self.config.initiator_prefix if role == 1 else self.config.respondent_prefix
+                    text = prefix + text
                 messages.append(text)
         return messages, senders
 
     def _info(self):
         return datasets.DatasetInfo(
-            description= self.config.description,
+            description=self.config.description,
             features=datasets.Features(self.config.features),
         )
 
@@ -114,6 +145,28 @@ class ReDIAL(datasets.GeneratorBasedBuilder):
             datasets.SplitGenerator(name=datasets.Split.TEST, gen_kwargs={"filepath": downloaded_files["test"]}),
         ]
 
+    movie_pattern = re.compile(r'@(\d+)')
+    default_movie_entity = '<movie>'
+
+    def _process_utt(self, utt, movieid2name, replace_movieId=True, remove_movie=False):
+        def convert(match):
+            movieid = match.group(0)[1:]
+            if movieid in movieid2name:
+                if remove_movie:
+                    return '<movie>'
+                movie_name = movieid2name[movieid]
+                movie_name = ' '.join(movie_name.split())
+                return ENTITY_PATTERN.format(movie_name)
+            else:
+                return match.group(0)
+
+        if replace_movieId:
+            utt = re.sub(self.movie_pattern, convert, utt)
+        utt = ' '.join(utt.split())
+        utt = html.unescape(utt)
+
+        return utt
+
     def _generate_examples(self, filepath):
         """This function returns the examples in the raw (text) form."""
         logger.info("generating examples from = %s", filepath)
@@ -141,7 +194,7 @@ class ReDIAL(datasets.GeneratorBasedBuilder):
 
         elif "SA" in self.config.name:
             Idx = 0
-            date_pattern = re.compile(r'\(\d{4}\)') # To match e.g. "(2009)"
+            date_pattern = re.compile(r'\(\d{4}\)')  # To match e.g. "(2009)"
             with open(filepath, encoding="utf-8") as f:
                 for line in f:
                     conversation = json.loads(line)
@@ -179,3 +232,15 @@ class ReDIAL(datasets.GeneratorBasedBuilder):
                         "movieIds": [int(movieId) for movieId in conversation["movieMentions"]]
                     }
                     Idx += 1
+        elif "formatted" in self.config.name:
+            Idx = 0
+            with open(filepath, encoding="utf-8") as f:
+                for line in f:
+                    dialog = json.loads(line)
+                    msgs, senders = self._flattenMessages(dialog, add_prefix=True)
+                    movieid2name = dialog['movieMentions']
+                    formatted_msgs = [self._process_utt(utt, movieid2name) for utt in msgs]
+                    yield Idx, {
+                        "messages": formatted_msgs,
+                    }
+                    Idx += 1