adapt to super scirep format

.gitignore

@@ -157,4 +157,6 @@ huggingface_hub/
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-.idea/
+.idea/
+results/
+data/

evaluation/embeddings_generator.py

@@ -15,11 +15,11 @@ class EmbeddingsGenerator:
         self.datasets = datasets
         self.models = models
 
-    def generate_embeddings(self, save_path: str = None) -> Dict[str, np.ndarray]:
+    def generate_embeddings(self, save_path: str = None, htrans=False, document=False) -> Dict[str, np.ndarray]:
         results = dict()
         try:
             for dataset, model in zip(self.datasets, self.models):
-                for batch, batch_ids in tqdm(dataset.batches(), total=len(dataset) // dataset.batch_size):
+                for batch, batch_ids in tqdm(dataset.batches(htrans, document), total=len(dataset) // dataset.batch_size):
                     emb = model(batch, batch_ids)
                     for paper_id, embedding in zip(batch_ids, emb.unbind()):
                         if type(paper_id) == tuple:
@@ -50,4 +50,4 @@ class EmbeddingsGenerator:
                 line_json = json.loads(line)
                 embeddings[line_json['doc_id']] = np.array(line_json['embedding'], dtype=np.float16)
         logger.info(f"Loaded {len(embeddings)} embeddings")
-        return embeddings
+        return embeddings

evaluation/encoders.py

@@ -74,7 +74,7 @@ class Model:
                 logger.info(f"Task id used: {self._task_id}")
 
         self.hidden_dim = hidden_dim
-        self.max_length = max_len #self.tokenizer.model_max_length
+        self.max_length = max_len
         self.use_fp16 = use_fp16
 
     @property
@@ -241,26 +241,33 @@ class HModel:
                             [np.concatenate([d[key] for d in sec_inputs]) for key in sec_inputs[0].keys()]))
         if self.config.max_doc_length > 1:
             for sample in batch:
+                if type(sample) == str:
+                    sample = [[sample]]
                 inputs.append(tokenize_document(self.tokenizer,sample, self.config.max_sent_length, self.config.max_sec_length, self.config.max_doc_length))
             input_ids = dict(zip(inputs[0].keys(), [torch.tensor(np.concatenate([d[key] for d in inputs])) for key in inputs[0].keys()]))
 
         else:
             for sample in batch:
-                sentences = sent_tokenize(sample.replace("[SEP]", "."))[:self.config.max_sec_length]
+                if type(sample) == str:
+                    sample = [sample]
+                else:
+                    sample = list(chain.from_iterable(sample))
+                sentences = sample[:self.config.max_sec_length]
                 tokenized_sample = self.tokenizer(sentences, padding="max_length", truncation=True,
                                            return_tensors="np", return_token_type_ids=False)
                 inputs.append({"input_ids": np.row_stack([tokenized_sample["input_ids"]] + [pad_input_ids] * (self.config.max_sec_length - len(sentences))).reshape((1, self.config.max_sent_length*self.config.max_sec_length)),
-                               "attention_mask": np.row_stack([tokenized_sample["attention_mask"]] + [pad_attention_mask] * (self.config.max_sec_length - len(sentences))).reshape((1, self.config.max_sent_length*self.config.max_sec_length))})
+                               "attention_mask": np.row_stack([tokenized_sample["attention_mask"]] + [pad_attention_mask] * (self.config.max_sec_length - len(sentences))).reshape((1, self.config.max_sent_length*self.config.max_sec_length)),
+                               "sec_mask": np.column_stack(
+                                   [np.ones((1, tokenized_sample["input_ids"].shape[0]), dtype=np.int64)] + (
+                                           self.config.max_sec_length - tokenized_sample["input_ids"].shape[0]) * [
+                                       np.zeros((1, 1), dtype=np.int64)]),
+                               "head_ids": np.array(
+                                   [[self.tokenizer.get_vocab()["<sec>"], self.tokenizer.get_vocab()["<doc>"]]],
+                                   dtype=np.int64)
+                               })
             input_ids = dict(zip(inputs[0].keys(), [torch.tensor(np.concatenate([d[key] for d in inputs])) for key in inputs[0].keys()]))
         input_ids = move_to_device(input_ids, "cuda")
-        flops = FlopCountAnalysis(self.encoder, input_ids["input_ids"])
 
-        def get_parameter_number(model):
-            total_num = sum(p.numel() for p in model.parameters())
-            trainable_num = sum(p.numel() for p in model.parameters() if p.requires_grad)
-            return {'Total': total_num, 'Trainable': trainable_num}
-
-        num_para = get_parameter_number(self.encoder)
         if self.variant == "default":
             output = self.encoder(**input_ids)
         elif type(self._task_id) != dict:

evaluation/eval_datasets.py

@@ -10,11 +10,11 @@ logger = logging.getLogger(__name__)
 class SimpleDataset:
 
     def __init__(self, data_path: Union[str, tuple], sep_token: str, batch_size=32,
-                 fields: List = None, key: str = None, processing_fn=None, document=False):
+                 fields: List = None, key: str = None, processing_fn=None):
         self.batch_size = batch_size
         self.sep_token = sep_token
         if not fields:
-            fields = ["title", "abstract", "full_text"]
+            fields = ["title", "abstract"]
         self.fields = fields
         logger.info(f"Loading test metadata from {data_path}")
         if not processing_fn:
@@ -27,67 +27,56 @@ class SimpleDataset:
         logger.info(f"Loaded {len(self.data)} documents")
         self.seen_ids = set()
         self.key = key
-        self.document=document
-
     def __len__(self):
         return len(self.data)
 
-    def batches(self):
-        return self.process_batches(self.data)
+    def batches(self, htrans=False, document=False):
+        return self.process_batches(self.data, htrans=htrans, document=document)
 
-    def process_batches(self, data: Union[datasets.Dataset, List]):
+    def process_batches(self, data: Union[datasets.Dataset, List], htrans=False, document=False):
         # create batches
         batch = []
         batch_ids = []
         batch_size = self.batch_size
         i = 0
-        if self.document:
-            key = "corpus_id" if not self.key else self.key
-            for d in data:
-                if key in d and str(d[key]) not in self.seen_ids:
-                    bid = str(d[key])
-                    self.seen_ids.add(bid)
-                    if "full_text" in d and d["full_text"] != []:
-                        text = [[d["title"]] + sent_tokenize(d["abstract"])]
-                        text += [[i["title"]] + i["sentences"] for i in d["full_text"]]
-                        # text = (f" {self.sep_token} ".join(text)).strip()
-                        if (i) % batch_size != 0 or i == 0:
-                            batch_ids.append(bid)
-                            batch.append(text)
-                        else:
-                            yield batch, batch_ids
-                            batch_ids = [bid]
-                            batch = [text]
-                        i += 1
-        else:
-            key = "doc_id" if not self.key else self.key
-            for d in data:
-                if key in d and d[key] not in self.seen_ids:
-                    bid = d[key]
-                    self.seen_ids.add(bid)
+        key = "doc_id" if not self.key else self.key
+        for d in data:
+            if key in d and d[key] not in self.seen_ids:
+                bid = d[key]
+                self.seen_ids.add(bid)
+                if htrans:
+                    text = [[d["title"]] + sent_tokenize(d["abstract"])]
+                    text += [[i["title"]] + i["sentences"] for i in d["full_text"]]
+                else:
                     text = []
                     for field in self.fields:
                         if d.get(field):
                             text.append(str(d[field]))
                     text = (f" {self.sep_token} ".join(text)).strip()
-                    if (i) % batch_size != 0 or i == 0:
-                        batch_ids.append(bid)
-                        batch.append(text)
-                    else:
-                        yield batch, batch_ids
-                        batch_ids = [bid]
-                        batch = [text]
-                    i += 1
+                    if document:
+                        for sec in d.get("full_text", []):
+                            text += (sec["title"] + " ")
+                            text += "".join(sec["sentences"])
+                if (i) % batch_size != 0 or i == 0:
+                    batch_ids.append(bid)
+                    batch.append(text)
+                else:
+                    yield batch, batch_ids
+                    batch_ids = [bid]
+                    batch = [text]
+                i += 1
         if len(batch) > 0:
             yield batch, batch_ids
 
 
 class IRDataset(SimpleDataset):
-    def __init__(self, data_path, sep_token, batch_size=32, fields=None, key=None, processing_fn=None, document=False):
-        super().__init__(data_path, sep_token, batch_size, fields, key, processing_fn, document)
+    def __init__(self, data_path, sep_token, batch_size=32, fields=None, key=None, processing_fn=None):
+        super().__init__(data_path, sep_token, batch_size, fields, key, processing_fn)
         self.queries, self.candidates = [], []
+        self.search = False
         for d in self.data:
             if type(d["query"]) == str:
+                self.search = True
                 self.queries.append({"title": d["query"], "doc_id": d["doc_id"]})
             else:
                 self.queries.append(d["query"])
@@ -96,9 +85,9 @@ class IRDataset(SimpleDataset):
     def __len__(self):
         return len(self.queries) + len(self.candidates)
 
-    def batches(self):
-        query_gen = self.process_batches(self.queries)
-        cand_gen = self.process_batches(self.candidates)
+    def batches(self, htrans=False, document=False):
+        query_gen = self.process_batches(self.queries, htrans=htrans and self.search, document=document and self.search)
+        cand_gen = self.process_batches(self.candidates, htrans=htrans, document=document)
         for q, q_ids in query_gen:
             q_ids = [(v, "q") for v in q_ids]
             yield q, q_ids

evaluation/evaluator.py

@@ -26,7 +26,7 @@ RANDOM_STATE = 42
 
 class Evaluator:
     def __init__(self, name: str, meta_dataset: Union[str, tuple], dataset_class, model: Model, batch_size: int,
-                 fields: list, key: str = None, process_fn=None, document=False):
+                 fields: list, key: str = None, process_fn=None):
         if model:
             if type(model) != list:
                 model = [model]
@@ -37,13 +37,13 @@ class Evaluator:
             #         m.tokenizer.sep_token = m.tokenizer.eos_token
             #         m.encoder.resize_token_embeddings(len(m.tokenizer))
             datasets = [dataset_class(meta_dataset, m.tokenizer.sep_token, batch_size, fields, key,
-                                    process_fn, document=document) for m in model]
+                                    process_fn) for m in model]
             self.embeddings_generator = EmbeddingsGenerator(datasets, model)
         self.name = name
 
-    def generate_embeddings(self, save_path: str = None):
+    def generate_embeddings(self, save_path: str = None, htrans=False, document=False):
         logger.info("Generating embeddings... this might take a while")
-        return self.embeddings_generator.generate_embeddings(save_path)
+        return self.embeddings_generator.generate_embeddings(save_path, htrans, document)
 
     @abstractmethod
     def evaluate(self, embeddings: Union[str, Dict[str, np.ndarray]], **kwargs) -> Dict[str, float]:
@@ -172,8 +172,8 @@ class SupervisedEvaluator(Evaluator):
 
 class IREvaluator(Evaluator):
     def __init__(self, name: str, meta_dataset: Union[str, tuple], test_dataset: Union[str, tuple], model: Model,
-                 metrics: tuple, dataset_class=IRDataset, batch_size: int = 16, fields: list = None, key=None, document=False):
-        super(IREvaluator, self).__init__(name, meta_dataset, dataset_class, model, batch_size, fields, key, document=document)
+                 metrics: tuple, dataset_class=IRDataset, batch_size: int = 16, fields: list = None, key=None):
+        super(IREvaluator, self).__init__(name, meta_dataset, dataset_class, model, batch_size, fields, key)
         self.test_dataset = test_dataset
         self.metrics = metrics
 

full_scirepeval_tasks.jsonl

@@ -1,3 +1,17 @@
-{"name":"Feeds-1","type":"proximity","data":{"meta":{"name":"howey/fullscirep_feeds_1", "config":""},"test":{"name":"howey/fullscirep_test_feeds_1","config":""}},"metrics":["map"]}
-{"name":"Feeds-M","type":"proximity","data":{"meta":{"name":"howey/fullscirep_feeds_m","config":""},"test":{"name":"howey/fullscirep_test_feeds_m","config":""}},"metrics":["map"]}
-{"name":"Highly Influential Citations","type":"proximity","data":{"meta":{"name":"howey/fullscirep_high_influence_cite","config":""},"test":{"name":"howey/fullscirep_test_high_influence_cite","config":""}},"metrics":["map"]}
+{"name":"Feeds-1","type":"proximity","data":{"meta":{"name":"allenai/scirepeval","config":"feeds_1"},"test":{"name":"allenai/scirepeval_test","config":"feeds_1"}},"metrics":["map"]}
+{"name":"Feeds-M","type":"proximity","data":{"meta":{"name":"allenai/scirepeval","config":"feeds_m"},"test":{"name":"allenai/scirepeval_test","config":"feeds_m"}},"metrics":["map"]}
+{"name":"Highly Influential Citations","type":"proximity","data":{"meta":{"name":"allenai/scirepeval","config":"high_influence_cite"},"test":{"name":"allenai/scirepeval_test","config":"high_influence_cite"}},"metrics":["map"]}
+{"name":"SciDocs Cite","type":"proximity","data":{"simple_format":true, "meta":{"name":"allenai/scirepeval","config":"scidocs_view_cite_read"},"test":{"name":"allenai/scirepeval_test","config":"scidocs_cite"}},"embeddings":{"save":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
+{"name":"SciDocs CoCite","type":"proximity","data":{"simple_format":true, "meta":{"name":"allenai/scirepeval","config":"scidocs_view_cite_read"},"test":{"name":"allenai/scirepeval_test","config":"scidocs_cocite"}},"embeddings":{"load":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
+{"name":"Fields of study","type":"classification","data":{"meta":{"name":"allenai/scirepeval","config":"fos"},"test":{"name":"allenai/scirepeval_test","config":"fos"}},"metrics":["f1_macro"],"few_shot":[{"sample_size":10,"iterations":50},{"sample_size":5,"iterations":100}],"multi_label":true}
+{"name":"Publication Year","type":"regression","data":{"meta":{"name":"allenai/scirepeval","config":"pub_year"},"test":{"name":"allenai/scirepeval_test","config":"pub_year"}},"metrics":["kendalltau"]}
+{"name":"Search","type":"adhoc_search","data":{"meta":{"name":"allenai/scirepeval","config":"search"},"test":{"name":"allenai/scirepeval_test","config":"search"}},"fields":["title","abstract","venue","year"],"metrics":["ndcg"]}
+{"name":"Feeds Title","type":"adhoc_search","data":{"meta":{"name":"allenai/scirepeval","config":"feeds_title"},"test":{"name":"allenai/scirepeval_test","config":"feeds_title"}},"metrics":["map"]}
+{"name":"Paper-Reviewer Matching","type":"proximity","data":{"meta":{"name":"allenai/scirepeval","config":"paper_reviewer_matching"},"test":{"name":"allenai/scirepeval_test","config":"paper_reviewer_matching"},"reviewers":{"name":"allenai/scirepeval_test","config":"reviewers"}},"metrics":["P_5", "P_10"]}
+{"name":"SciDocs CoView","type":"proximity","data":{"simple_format":true, "meta":{"name":"allenai/scirepeval","config":"scidocs_view_cite_read"},"test":{"name":"allenai/scirepeval_test","config":"scidocs_view"}},"embeddings":{"load":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
+{"name":"SciDocs CoRead","type":"proximity","data":{"simple_format":true, "meta":{"name":"allenai/scirepeval","config":"scidocs_view_cite_read"},"test":{"name":"allenai/scirepeval_test","config":"scidocs_read"}},"embeddings":{"load":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
+{"name":"Peer Review Score","type":"regression","data":{"meta":{"name":"allenai/scirepeval","config":"peer_review_score_hIndex"},"test":{"name":"allenai/scirepeval_test","config":"peer_review_score"}},"embeddings":{"save":"embeddings/peer_review_score_hIndex.jsonl"},"metrics":["kendalltau"]}
+{"name":"Max hIndex","type":"regression","data":{"meta":{"name":"allenai/scirepeval","config":"peer_review_score_hIndex"},"test":{"name":"allenai/scirepeval_test","config":"hIndex"}},"embeddings":{"load":"embeddings/peer_review_score_hIndex.jsonl"},"metrics":["kendalltau"]}
+{"name":"Tweet Mentions","type":"regression","data":{"meta":{"name":"allenai/scirepeval","config":"tweet_mentions"},"test":{"name":"allenai/scirepeval_test","config":"tweet_mentions"}},"metrics":["kendalltau"]}
+{"name":"Citation Count","type":"regression","data":{"meta":{"name":"allenai/scirepeval","config":"cite_count"},"test":{"name":"allenai/scirepeval_test","config":"cite_count"}},"metrics":["kendalltau"]}
+

scirepeval.py

@@ -20,7 +20,7 @@ pl.seed_everything(42, workers=True)
 
 class SciRepEval:
 
-    def __init__(self, tasks_config: str = "scirepeval_tasks.jsonl", task_list: List[str] = None,
+    def __init__(self, tasks_config: str = "super_scirep.jsonl", task_list: List[str] = None,
                  task_formats: List[str] = None, batch_size: int = 32, document=False):
         tasks_dict = dict()
         task_by_formats = dict()
@@ -101,8 +101,8 @@ class SciRepEval:
                     evaluator = ReviewerMatchingEvaluator(task_name, model=model, **kwargs)
                 else:
                     data_class = SimpleDataset if task_data.get("simple_format") else IRDataset
-                    evaluator = IREvaluator(task_name, model=model, dataset_class=data_class, document=self.document, **kwargs)
-            embeddings = evaluator.generate_embeddings(save_path) if not load_path else load_path
+                    evaluator = IREvaluator(task_name, model=model, dataset_class=data_class, **kwargs)
+            embeddings = evaluator.generate_embeddings(save_path, htrans=args.htrans, document=args.document) if not load_path else load_path
             results = evaluator.evaluate(embeddings)
             if not few_shot_evaluators:
                 final_results[task_name] = results
@@ -121,10 +121,8 @@ class SciRepEval:
 
 
 if __name__ == "__main__":
-    import datasets
-    datasets.load_dataset('howey/super_scirep', "cite_count")
     parser = argparse.ArgumentParser()
-    parser.add_argument('--tasks-config', help='path to the task config file', default="scirepeval_tasks.jsonl")
+    parser.add_argument('--tasks-config', help='path to the task config file', default="super_scirep.jsonl")
     parser.add_argument('--mtype', help='Model variant to be used (default, pals, adapters, fusion)', default="default")
     parser.add_argument('--gpt3-model', help='Name of embedding model in case of using openai api', default=None)
     parser.add_argument('--model', '-m', help='HuggingFace model to be used')

scirepeval_tasks.jsonl

@@ -4,7 +4,6 @@
 {"name":"Feeds-M","type":"proximity","data":{"meta":{"name":"allenai/scirepeval","config":"feeds_m"},"test":{"name":"allenai/scirepeval_test","config":"feeds_m"}},"metrics":["map"]}
 {"name":"Feeds Title","type":"adhoc_search","data":{"meta":{"name":"allenai/scirepeval","config":"feeds_title"},"test":{"name":"allenai/scirepeval_test","config":"feeds_title"}},"metrics":["map"]}
 {"name":"TREC-CoVID","type":"adhoc_search","data":{"meta":{"name":"allenai/scirepeval","config":"trec_covid"},"test":{"name":"allenai/scirepeval_test","config":"trec_covid"}},"metrics":["ndcg"]}
-{"name":"Paper-Reviewer Matching","type":"proximity","data":{"meta":{"name":"allenai/scirepeval","config":"paper_reviewer_matching"},"test":{"name":"allenai/scirepeval_test","config":"paper_reviewer_matching"},"reviewers":{"name":"allenai/scirepeval_test","config":"reviewers"}},"metrics":["P_5", "P_10"]}
 {"name":"Peer Review Score","type":"regression","data":{"meta":{"name":"allenai/scirepeval","config":"peer_review_score_hIndex"},"test":{"name":"allenai/scirepeval_test","config":"peer_review_score"}},"embeddings":{"save":"embeddings/peer_review_score_hIndex.jsonl"},"metrics":["kendalltau"]}
 {"name":"Max hIndex","type":"regression","data":{"meta":{"name":"allenai/scirepeval","config":"peer_review_score_hIndex"},"test":{"name":"allenai/scirepeval_test","config":"hIndex"}},"embeddings":{"load":"embeddings/peer_review_score_hIndex.jsonl"},"metrics":["kendalltau"]}
 {"name":"Tweet Mentions","type":"regression","data":{"meta":{"name":"allenai/scirepeval","config":"tweet_mentions"},"test":{"name":"allenai/scirepeval_test","config":"tweet_mentions"}},"metrics":["kendalltau"]}

super_scirep.jsonl

@@ -0,0 +1,16 @@
+{"name":"Feeds-1","type":"proximity","data":{"meta":{"name":"howey/super_scirep","config":"feeds_1"},"test":{"name":"howey/super_scirep_test","config":"feeds_1"}},"metrics":["map"]}
+{"name":"Feeds-M","type":"proximity","data":{"meta":{"name":"howey/super_scirep","config":"feeds_m"},"test":{"name":"howey/super_scirep_test","config":"feeds_m"}},"metrics":["map"]}
+{"name":"Highly Influential Citations","type":"proximity","data":{"meta":{"name":"howey/super_scirep","config":"high_influence_cite"},"test":{"name":"howey/super_scirep_test","config":"high_influence_cite"}},"metrics":["map"]}
+{"name":"SciDocs Cite","type":"proximity","data":{"simple_format":true, "meta":{"name":"howey/super_scirep","config":"scidocs_view_cite_read"},"test":{"name":"howey/super_scirep_test","config":"scidocs_cite"}},"embeddings":{"save":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
+{"name":"SciDocs CoCite","type":"proximity","data":{"simple_format":true, "meta":{"name":"howey/super_scirep","config":"scidocs_view_cite_read"},"test":{"name":"howey/super_scirep_test","config":"scidocs_cocite"}},"embeddings":{"load":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
+{"name":"Fields of study","type":"classification","data":{"meta":{"name":"howey/super_scirep","config":"fos"},"test":{"name":"howey/super_scirep_test","config":"fos"}},"metrics":["f1_macro"],"few_shot":[{"sample_size":10,"iterations":50},{"sample_size":5,"iterations":100}],"multi_label":true}
+{"name":"Publication Year","type":"regression","data":{"meta":{"name":"howey/super_scirep","config":"pub_year"},"test":{"name":"howey/super_scirep_test","config":"pub_year"}},"metrics":["kendalltau"]}
+{"name":"Search","type":"adhoc_search","data":{"meta":{"name":"howey/super_scirep","config":"search"},"test":{"name":"howey/super_scirep_test","config":"search"}},"fields":["title","abstract","venue","year"],"metrics":["ndcg"]}
+{"name":"Feeds Title","type":"adhoc_search","data":{"meta":{"name":"howey/super_scirep","config":"feeds_title"},"test":{"name":"howey/super_scirep_test","config":"feeds_title"}},"metrics":["map"]}
+{"name":"Paper-Reviewer Matching","type":"proximity","data":{"meta":{"name":"howey/super_scirep","config":"paper_reviewer_matching"},"test":{"name":"howey/super_scirep_test","config":"paper_reviewer_matching"},"reviewers":{"name":"howey/super_scirep_test","config":"reviewers"}},"metrics":["P_5", "P_10"]}
+{"name":"SciDocs CoView","type":"proximity","data":{"simple_format":true, "meta":{"name":"howey/super_scirep","config":"scidocs_view_cite_read"},"test":{"name":"howey/super_scirep_test","config":"scidocs_view"}},"embeddings":{"load":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
+{"name":"SciDocs CoRead","type":"proximity","data":{"simple_format":true, "meta":{"name":"howey/super_scirep","config":"scidocs_view_cite_read"},"test":{"name":"howey/super_scirep_test","config":"scidocs_read"}},"embeddings":{"load":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
+{"name":"Peer Review Score","type":"regression","data":{"meta":{"name":"howey/super_scirep","config":"peer_review_score_hIndex"},"test":{"name":"howey/super_scirep_test","config":"peer_review_score"}},"embeddings":{"save":"embeddings/peer_review_score_hIndex.jsonl"},"metrics":["kendalltau"]}
+{"name":"Max hIndex","type":"regression","data":{"meta":{"name":"howey/super_scirep","config":"peer_review_score_hIndex"},"test":{"name":"howey/super_scirep_test","config":"hIndex"}},"embeddings":{"load":"embeddings/peer_review_score_hIndex.jsonl"},"metrics":["kendalltau"]}
+{"name":"Tweet Mentions","type":"regression","data":{"meta":{"name":"howey/super_scirep","config":"tweet_mentions"},"test":{"name":"howey/super_scirep_test","config":"tweet_mentions"}},"metrics":["kendalltau"]}
+{"name":"Citation Count","type":"regression","data":{"meta":{"name":"howey/super_scirep","config":"cite_count"},"test":{"name":"howey/super_scirep_test","config":"cite_count"}},"metrics":["kendalltau"]}