| {"repo": "Tiiiger/bert_score", "pull_number": 16, "instance_id": "Tiiiger__bert_score-16", "issue_numbers": "", "base_commit": "8781157cd18816bf94cedd0a819119c19431cbcb", "patch": "diff --git a/bert_score/__init__.py b/bert_score/__init__.py\n--- a/bert_score/__init__.py\n+++ b/bert_score/__init__.py\n@@ -1,3 +1,3 @@\n-__version__ = '0.1.2'\n+__version__ = '0.2.0'\n from .utils import *\n from .score import *\ndiff --git a/bert_score/score.py b/bert_score/score.py\n--- a/bert_score/score.py\n+++ b/bert_score/score.py\n@@ -2,19 +2,46 @@\n import time\n import argparse\n import torch\n-from collections import defaultdict\n-from pytorch_pretrained_bert import BertTokenizer, BertModel, BertForMaskedLM\n import matplotlib\n import matplotlib.pyplot as plt\n import numpy as np\n \n-from .utils import get_idf_dict, bert_cos_score_idf,\\\n- get_bert_embedding, bert_types\n+from collections import defaultdict\n+from transformers import AutoModel, AutoTokenizer\n+\n+from .utils import (get_idf_dict, bert_cos_score_idf,\n+ get_bert_embedding, model_types,\n+ lang2model, model2layers, get_hash)\n+\n \n __all__ = ['score', 'plot_example']\n \n-def score(cands, refs, bert=\"bert-base-multilingual-cased\",\n- num_layers=8, verbose=False, no_idf=False, batch_size=64):\n+def get_model(model_type, num_layers, all_layers=None):\n+ model = AutoModel.from_pretrained(model_type)\n+ model.eval()\n+\n+ # drop unused layers\n+ if not all_layers:\n+ if 'bert' == model_type[:4] or 'roberta' == model_type[:7]:\n+ model.encoder.layer =\\\n+ torch.nn.ModuleList([layer for layer in model.encoder.layer[:num_layers]])\n+ elif 'xlnet' == model_type[:5]:\n+ model.layer =\\\n+ torch.nn.ModuleList([layer for layer in model.layer[:num_layers]])\n+ elif 'xlm' in model_type[:3]:\n+ model.n_layers = num_layers\n+ else:\n+ raise ValueError(\"Not supported\")\n+ else:\n+ if 'bert' == model_type[:4] or 'roberta' == model_type[:7]:\n+ model.encoder.output_hidden_states = True\n+ else:\n+ model.output_hidden_states = True\n+ return model\n+\n+def score(cands, refs, model_type=None, num_layers=None, verbose=False,\n+ idf=False, batch_size=64, nthreads=4, all_layers=False, lang=None,\n+ return_hash=False):\n \"\"\"\n BERTScore metric.\n \n@@ -24,31 +51,39 @@ def score(cands, refs, bert=\"bert-base-multilingual-cased\",\n - :param: `bert` (str): bert specification\n - :param: `num_layers` (int): the layer of representation to use\n - :param: `verbose` (bool): turn on intermediate status update\n- - :param: `no_idf` (bool): do not use idf weighting\n+ - :param: `idf` (bool): use idf weighting\n - :param: `batch_size` (int): bert score processing batch size\n+ - :param: `lang` (str): language of the sentences\n+ - :param: `return_hash` (bool): return hash code of the setting\n \"\"\"\n assert len(cands) == len(refs)\n- assert bert in bert_types\n \n- tokenizer = BertTokenizer.from_pretrained(bert)\n- model = BertModel.from_pretrained(bert)\n- model.eval()\n+ assert lang is not None or model_type is not None, \\\n+ 'Either lang or model_type should be specified'\n+\n+ if model_type is None:\n+ lang = lang.lower()\n+ model_type = lang2model[lang]\n+ if num_layers is None:\n+ num_layers = model2layers[model_type]\n+\n+\n+ assert model_type in model_types\n+ tokenizer = AutoTokenizer.from_pretrained(model_type)\n+ model = get_model(model_type, num_layers, all_layers)\n device = 'cuda' if torch.cuda.is_available() else 'cpu'\n model.to(device)\n \n- # drop unused layers\n- model.encoder.layer = torch.nn.ModuleList([layer for layer in model.encoder.layer[:num_layers]])\n-\n- if no_idf:\n+ if not idf:\n idf_dict = defaultdict(lambda: 1.)\n # set idf for [SEP] and [CLS] to 0\n- idf_dict[101] = 0\n- idf_dict[102] = 0\n+ idf_dict[tokenizer.sep_token_id] = 0\n+ idf_dict[tokenizer.cls_token_id] = 0\n else:\n if verbose:\n print('preparing IDF dict...')\n start = time.perf_counter()\n- idf_dict = get_idf_dict(refs, tokenizer)\n+ idf_dict = get_idf_dict(refs, tokenizer, nthreads=nthreads)\n if verbose:\n print('done in {:.2f} seconds'.format(time.perf_counter() - start))\n \n@@ -56,18 +91,23 @@ def score(cands, refs, bert=\"bert-base-multilingual-cased\",\n print('calculating scores...')\n start = time.perf_counter()\n all_preds = bert_cos_score_idf(model, refs, cands, tokenizer, idf_dict,\n- verbose=verbose, device=device, batch_size=batch_size)\n+ verbose=verbose, device=device, \n+ batch_size=batch_size, all_layers=all_layers)\n \n- P = all_preds[:, 0].cpu()\n- R = all_preds[:, 1].cpu()\n- F1 = all_preds[:, 2].cpu()\n+ P = all_preds[..., 0].cpu()\n+ R = all_preds[..., 1].cpu()\n+ F1 = all_preds[..., 2].cpu()\n if verbose:\n- print('done in {:.2f} seconds'.format(time.perf_counter() - start))\n+ time_diff = time.perf_counter() - start\n+ print(f'done in {time_diff:.2f} seconds, {len(refs) / time_diff:.2f} sentences/sec')\n \n- return P, R, F1\n+ if return_hash:\n+ return (P, R, F1), get_hash(model_type, num_layers, idf)\n+ else:\n+ return P, R, F1\n \n-def plot_example(h, r, verbose=False, bert=\"bert-base-multilingual-cased\",\n- num_layers=8, fname=''):\n+# Under Construction\n+def plot_example(candidate, reference, model_type=None, lang=None, num_layers=None, fname=''):\n \"\"\"\n BERTScore metric.\n \n@@ -78,38 +118,41 @@ def plot_example(h, r, verbose=False, bert=\"bert-base-multilingual-cased\",\n - :param: `bert` (str): bert specification\n - :param: `num_layers` (int): the layer of representation to use\n \"\"\"\n- assert bert in bert_types\n+ assert isinstance(candidate, str)\n+ assert isinstance(reference, str)\n \n- if verbose:\n- print('loading BERT model...')\n- tokenizer = BertTokenizer.from_pretrained(bert)\n- model = BertModel.from_pretrained(bert)\n- model.eval()\n+ assert lang is not None or model_type is not None, \\\n+ 'Either lang or model_type should be specified'\n+\n+ if model_type is None:\n+ lang = lang.lower()\n+ model_type = lang2model[lang]\n+ if num_layers is None:\n+ num_layers = model2layers[model_type]\n+\n+ assert model_type in model_types\n+ tokenizer = AutoTokenizer.from_pretrained(model_type)\n+ model = get_model(model_type, num_layers)\n device = 'cuda' if torch.cuda.is_available() else 'cpu'\n model.to(device)\n \n- h_tokens = ['[CLS]'] + tokenizer.tokenize(h) + ['[SEP]']\n- r_tokens = ['[CLS]'] + tokenizer.tokenize(r) + ['[SEP]']\n-\n- model.encoder.layer = torch.nn.ModuleList([layer for layer in model.encoder.layer[:num_layers]])\n idf_dict = defaultdict(lambda: 1.)\n-\n- ref_embedding, ref_lens, ref_masks, padded_idf = get_bert_embedding([r], model, tokenizer, idf_dict,\n- device=device)\n- hyp_embedding, ref_lens, ref_masks, padded_idf = get_bert_embedding([h], model, tokenizer, idf_dict,\n- device=device)\n-\n+ # set idf for [SEP] and [CLS] to 0\n+ idf_dict[tokenizer.sep_token_id] = 0\n+ idf_dict[tokenizer.cls_token_id] = 0\n+\n+ hyp_embedding, masks, padded_idf = get_bert_embedding([candidate], model, tokenizer, idf_dict,\n+ device=device, all_layers=False)\n+ ref_embedding, masks, padded_idf = get_bert_embedding([reference], model, tokenizer, idf_dict,\n+ device=device, all_layers=False)\n ref_embedding.div_(torch.norm(ref_embedding, dim=-1).unsqueeze(-1))\n hyp_embedding.div_(torch.norm(hyp_embedding, dim=-1).unsqueeze(-1))\n-\n- batch_size = ref_embedding.size(1)\n-\n- sim = torch.bmm(hyp_embedding, ref_embedding.transpose(1, 2)).cpu()\n- sim = sim.squeeze(0).numpy()\n+ sim = torch.bmm(hyp_embedding, ref_embedding.transpose(1, 2))\n+ sim = sim.squeeze(0).cpu()\n \n # remove [CLS] and [SEP] tokens \n- r_tokens = r_tokens[1:-1]\n- h_tokens = h_tokens[1:-1]\n+ r_tokens = [tokenizer.decode([i]) for i in tokenizer.encode(reference)]\n+ h_tokens = [tokenizer.decode([i]) for i in tokenizer.encode(candidate)]\n sim = sim[1:-1,1:-1]\n \n fig, ax = plt.subplots(figsize=(len(r_tokens)*0.8, len(h_tokens)*0.8))\n@@ -121,8 +164,9 @@ def plot_example(h, r, verbose=False, bert=\"bert-base-multilingual-cased\",\n # ... and label them with the respective list entries\n ax.set_xticklabels(r_tokens, fontsize=10)\n ax.set_yticklabels(h_tokens, fontsize=10)\n- plt.xlabel(\"Refernce\", fontsize=10)\n- plt.ylabel(\"Candidate\", fontsize=10)\n+ plt.xlabel(\"Refernce (tokenized)\", fontsize=14)\n+ plt.ylabel(\"Candidate (tokenized)\", fontsize=14)\n+ plt.title(\"Similarity Matrix\", fontsize=14)\n \n # Rotate the tick labels and set their alignment.\n plt.setp(ax.get_xticklabels(), rotation=45, ha=\"right\",\n@@ -131,15 +175,10 @@ def plot_example(h, r, verbose=False, bert=\"bert-base-multilingual-cased\",\n # Loop over data dimensions and create text annotations.\n for i in range(len(h_tokens)):\n for j in range(len(r_tokens)):\n- text = ax.text(j, i, '{:.3f}'.format(sim[i, j]),\n- ha=\"center\", va=\"center\", color=\"k\" if sim[i, j] < 0.6 else \"w\")\n-\n-# P = sim.max(1).mean()\n-# R = sim.max(0).mean()\n-# F1 = 2 * P * R / (P + R)\n+ text = ax.text(j, i, '{:.3f}'.format(sim[i, j].item()),\n+ ha=\"center\", va=\"center\", color=\"k\" if sim[i, j].item() < 0.6 else \"w\")\n \n fig.tight_layout()\n-# plt.title(\"BERT-F1: {:.3f}\".format(F1), fontsize=10)\n if fname != \"\":\n print(\"Saved figure to file: \", fname+\".png\")\n plt.savefig(fname+'.png', dpi=100)\ndiff --git a/bert_score/utils.py b/bert_score/utils.py\n--- a/bert_score/utils.py\n+++ b/bert_score/utils.py\n@@ -1,3 +1,4 @@\n+import sys\n import torch\n from math import log\n from itertools import chain\n@@ -5,18 +6,40 @@\n from multiprocessing import Pool\n from functools import partial\n from tqdm.auto import tqdm\n-\n-__all__ = ['bert_types']\n-\n-bert_types = [\n- 'bert-base-uncased',\n- 'bert-large-uncased',\n- 'bert-base-cased',\n- 'bert-large-cased',\n- 'bert-base-multilingual-uncased',\n- 'bert-base-multilingual-cased',\n- 'bert-base-chinese',\n-]\n+from torch.nn.utils.rnn import pad_sequence\n+\n+from transformers import BertConfig, XLNetConfig, XLMConfig, RobertaConfig\n+\n+from . import __version__\n+\n+__all__ = ['model_types']\n+\n+model_types = list(BertConfig.pretrained_config_archive_map.keys())+\\\n+ list(XLNetConfig.pretrained_config_archive_map.keys())+\\\n+ list(RobertaConfig.pretrained_config_archive_map.keys())+\\\n+ list(XLMConfig.pretrained_config_archive_map.keys())\n+\n+lang2model = defaultdict(lambda: 'bert-base-multilingual-cased')\n+lang2model.update({\n+ 'en': 'roberta-large',\n+ 'zh': 'bert-base-chinese',\n+})\n+\n+model2layers = {\n+ 'bert-base-multilingual-cased' : 9,\n+ 'bert-base-uncased': 9,\n+ 'bert-large-uncased': 18,\n+ 'bert-base-cased-finetuned-mrpc': 9,\n+ 'bert-base-multilingual-cased': 9,\n+ 'bert-base-chinese': 8,\n+ 'roberta-base': 10,\n+ 'roberta-large': 17,\n+ 'roberta-large-mnli': 19,\n+ 'xlnet-base-cased': 5, \n+ 'xlnet-large-cased': 7, \n+ 'xlm-mlm-en-2048': 7, \n+ 'xlm-mlm-100-1280': 11,\n+}\n \n def padding(arr, pad_token, dtype=torch.long):\n lens = torch.LongTensor([len(a) for a in arr])\n@@ -28,19 +51,21 @@ def padding(arr, pad_token, dtype=torch.long):\n mask[i, :lens[i]] = 1\n return padded, lens, mask\n \n-\n-def bert_encode(model, x, attention_mask):\n+def bert_encode(model, x, attention_mask, all_layers=False):\n model.eval()\n x_seg = torch.zeros_like(x, dtype=torch.long)\n with torch.no_grad():\n- x_encoded_layers, pooled_output = model(x, x_seg, attention_mask=attention_mask, output_all_encoded_layers=False)\n- return x_encoded_layers\n+ out = model(x, attention_mask=attention_mask)\n+ if all_layers:\n+ emb = torch.stack(out[-1], dim=2)\n+ else:\n+ emb = out[0]\n+ return emb\n \n \n def process(a, tokenizer=None):\n if not tokenizer is None:\n- a = [\"[CLS]\"]+tokenizer.tokenize(a)+[\"[SEP]\"]\n- a = tokenizer.convert_tokens_to_ids(a)\n+ a = tokenizer.encode(a.strip(), add_special_tokens=True)\n return set(a)\n \n \n@@ -67,8 +92,7 @@ def get_idf_dict(arr, tokenizer, nthreads=4):\n return idf_dict\n \n \n-def collate_idf(arr, tokenize, numericalize, idf_dict,\n- pad=\"[PAD]\", device='cuda:0'):\n+def collate_idf(arr, tokenizer, idf_dict, device='cuda:0'):\n \"\"\"\n Helper function that pads a list of sentences to hvae the same length and\n loads idf score for words in the sentences.\n@@ -84,15 +108,14 @@ def collate_idf(arr, tokenize, numericalize, idf_dict,\n - :param: `pad` (str): the padding token.\n - :param: `device` (str): device to use, e.g. 'cpu' or 'cuda'\n \"\"\"\n- arr = [[\"[CLS]\"]+tokenize(a)+[\"[SEP]\"] for a in arr]\n- arr = [numericalize(a) for a in arr]\n+ arr = [tokenizer.encode(a, add_special_tokens=True) for a in arr]\n \n idf_weights = [[idf_dict[i] for i in a] for a in arr]\n \n- pad_token = numericalize([pad])[0]\n+ pad_token = tokenizer._convert_token_to_id(tokenizer.pad_token)\n \n padded, lens, mask = padding(arr, pad_token, dtype=torch.long)\n- padded_idf, _, _ = padding(idf_weights, pad_token, dtype=torch.float)\n+ padded_idf, _, _ = padding(idf_weights, 0, dtype=torch.float)\n \n padded = padded.to(device=device)\n mask = mask.to(device=device)\n@@ -101,7 +124,8 @@ def collate_idf(arr, tokenize, numericalize, idf_dict,\n \n \n def get_bert_embedding(all_sens, model, tokenizer, idf_dict,\n- batch_size=-1, device='cuda:0'):\n+ batch_size=-1, device='cuda:0', \n+ all_layers=False):\n \"\"\"\n Compute BERT embedding in batches.\n \n@@ -115,7 +139,7 @@ def get_bert_embedding(all_sens, model, tokenizer, idf_dict,\n \"\"\"\n \n padded_sens, padded_idf, lens, mask = collate_idf(all_sens,\n- tokenizer.tokenize, tokenizer.convert_tokens_to_ids,\n+ tokenizer,\n idf_dict,\n device=device)\n \n@@ -125,18 +149,19 @@ def get_bert_embedding(all_sens, model, tokenizer, idf_dict,\n with torch.no_grad():\n for i in range(0, len(all_sens), batch_size):\n batch_embedding = bert_encode(model, padded_sens[i:i+batch_size],\n- attention_mask=mask[i:i+batch_size])\n- # batch_embedding = torch.stack(batch_embedding)\n+ attention_mask=mask[i:i+batch_size],\n+ all_layers=all_layers)\n embeddings.append(batch_embedding)\n del batch_embedding\n \n total_embedding = torch.cat(embeddings, dim=0)\n \n- return total_embedding, lens, mask, padded_idf\n+ return total_embedding, mask, padded_idf\n \n \n-def greedy_cos_idf(ref_embedding, ref_lens, ref_masks, ref_idf,\n- hyp_embedding, hyp_lens, hyp_masks, hyp_idf):\n+def greedy_cos_idf(ref_embedding, ref_masks, ref_idf,\n+ hyp_embedding, hyp_masks, hyp_idf,\n+ all_layers=False):\n \"\"\"\n Compute greedy matching based on cosine similarity.\n \n@@ -158,16 +183,24 @@ def greedy_cos_idf(ref_embedding, ref_lens, ref_masks, ref_idf,\n - :param: `hyp_idf` (torch.Tensor): BxK, idf score of each word\n piece in the candidate setence\n \"\"\"\n-\n ref_embedding.div_(torch.norm(ref_embedding, dim=-1).unsqueeze(-1))\n hyp_embedding.div_(torch.norm(hyp_embedding, dim=-1).unsqueeze(-1))\n \n+ if all_layers:\n+ B, _, L, D = hyp_embedding.size()\n+ hyp_embedding = hyp_embedding.transpose(1, 2).transpose(0, 1)\\\n+ .contiguous().view(L*B, hyp_embedding.size(1), D)\n+ ref_embedding = ref_embedding.transpose(1, 2).transpose(0, 1)\\\n+ .contiguous().view(L*B, ref_embedding.size(1), D)\n batch_size = ref_embedding.size(0)\n-\n sim = torch.bmm(hyp_embedding, ref_embedding.transpose(1, 2))\n masks = torch.bmm(hyp_masks.unsqueeze(2).float(), ref_masks.unsqueeze(1).float())\n- masks = masks.expand(batch_size, masks.size(1), masks.size(2))\\\n- .contiguous().view_as(sim)\n+ if all_layers:\n+ masks = masks.unsqueeze(0).expand(L, -1, -1, -1)\\\n+ .contiguous().view_as(sim)\n+ else:\n+ masks = masks.expand(batch_size, -1, -1)\\\n+ .contiguous().view_as(sim)\n \n masks = masks.float().to(sim.device)\n sim = sim * masks\n@@ -179,14 +212,38 @@ def greedy_cos_idf(ref_embedding, ref_lens, ref_masks, ref_idf,\n ref_idf.div_(ref_idf.sum(dim=1, keepdim=True))\n precision_scale = hyp_idf.to(word_precision.device)\n recall_scale = ref_idf.to(word_recall.device)\n+ if all_layers:\n+ precision_scale = precision_scale.unsqueeze(0)\\\n+ .expand(L, B, -1).contiguous().view_as(word_precision)\n+ recall_scale = recall_scale.unsqueeze(0)\\\n+ .expand(L, B, -1).contiguous().view_as(word_recall)\n P = (word_precision * precision_scale).sum(dim=1)\n R = (word_recall * recall_scale).sum(dim=1)\n- \n F = 2 * P * R / (P + R)\n+\n+ hyp_zero_mask = hyp_masks.sum(dim=1).eq(2)\n+ ref_zero_mask = ref_masks.sum(dim=1).eq(2)\n+\n+ if all_layers:\n+ P = P.view(L, B)\n+ R = R.view(L, B)\n+ F = F.view(L, B)\n+\n+ if torch.any(hyp_zero_mask):\n+ print(\"Warning: Empty candidate sentence; Setting precision to be 0.\", file=sys.stderr)\n+ P = P.masked_fill(hyp_zero_mask, 0.)\n+\n+ if torch.any(ref_zero_mask):\n+ print(\"Warning: Empty candidate sentence; Setting recall to be 0.\", file=sys.stderr)\n+ R = R.masked_fill(ref_zero_mask, 0.)\n+\n+ F = F.masked_fill(torch.isnan(F), 0.)\n+\n return P, R, F\n \n def bert_cos_score_idf(model, refs, hyps, tokenizer, idf_dict,\n- verbose=False, batch_size=64, device='cuda:0'):\n+ verbose=False, batch_size=64, device='cuda:0',\n+ all_layers=False):\n \"\"\"\n Compute BERTScore.\n \n@@ -202,17 +259,62 @@ def bert_cos_score_idf(model, refs, hyps, tokenizer, idf_dict,\n - :param: `device` (str): device to use, e.g. 'cpu' or 'cuda'\n \"\"\"\n preds = []\n+ def dedup_and_sort(l):\n+ return sorted(list(set(l)), key= lambda x : len(x.split(\" \")))\n+ sentences = dedup_and_sort(refs+hyps)\n+ embs = []\n+ iter_range = range(0, len(sentences), batch_size)\n+ if verbose: \n+ print(\"computing bert embedding.\")\n+ iter_range = tqdm(iter_range)\n+ stats_dict = dict()\n+ for batch_start in iter_range:\n+ sen_batch = sentences[batch_start:batch_start+batch_size]\n+ embs, masks, padded_idf = get_bert_embedding(sen_batch, model, tokenizer, idf_dict,\n+ device=device, all_layers=all_layers)\n+ embs = embs.cpu()\n+ masks = masks.cpu()\n+ padded_idf = padded_idf.cpu()\n+ for i, sen in enumerate(sen_batch):\n+ sequence_len = masks[i].sum().item()\n+ emb = embs[i, :sequence_len]\n+ idf = padded_idf[i, :sequence_len]\n+ stats_dict[sen] = (emb, idf)\n+ \n+ def pad_batch_stats(sen_batch, stats_dict, device):\n+ stats = [stats_dict[s] for s in sen_batch]\n+ emb, idf = zip(*stats)\n+ lens = [e.size(0) for e in emb]\n+ emb_pad = pad_sequence(emb, batch_first=True, padding_value=2.)\n+ idf_pad = pad_sequence(idf, batch_first=True)\n+ def length_to_mask(lens):\n+ lens = torch.tensor(lens, dtype=torch.long)\n+ max_len = max(lens)\n+ base = torch.arange(max_len, dtype=torch.long)\\\n+ .expand(len(lens), max_len)\n+ return base < lens.unsqueeze(1)\n+ pad_mask = length_to_mask(lens)\n+ return emb_pad.to(device), pad_mask.to(device), idf_pad.to(device)\n+ \n+\n+ device = next(model.parameters()).device\n iter_range = range(0, len(refs), batch_size)\n- if verbose: iter_range = tqdm(iter_range)\n+ if verbose: \n+ print(\"computing greedy matching.\")\n+ iter_range = tqdm(iter_range)\n for batch_start in iter_range:\n batch_refs = refs[batch_start:batch_start+batch_size]\n batch_hyps = hyps[batch_start:batch_start+batch_size]\n- ref_stats = get_bert_embedding(batch_refs, model, tokenizer, idf_dict,\n- device=device)\n- hyp_stats = get_bert_embedding(batch_hyps, model, tokenizer, idf_dict,\n- device=device)\n-\n- P, R, F1 = greedy_cos_idf(*ref_stats, *hyp_stats)\n- preds.append(torch.stack((P, R, F1), dim=1).cpu())\n- preds = torch.cat(preds, dim=0)\n+ ref_stats = pad_batch_stats(batch_refs, stats_dict, device)\n+ hyp_stats = pad_batch_stats(batch_hyps, stats_dict, device)\n+\n+ P, R, F1 = greedy_cos_idf(*ref_stats, *hyp_stats, all_layers)\n+ preds.append(torch.stack((P, R, F1), dim=-1).cpu())\n+ preds = torch.cat(preds, dim=1 if all_layers else 0)\n return preds\n+\n+\n+def get_hash(model, num_layers, idf):\n+ msg = '{}_L{}{}_version={}'.format(\n+ model, num_layers, '_idf' if idf else '_no-idf', __version__)\n+ return msg\n\\ No newline at end of file\ndiff --git a/cli/score.py b/cli/score.py\n--- a/cli/score.py\n+++ b/cli/score.py\n@@ -4,21 +4,20 @@\n import argparse\n import torch\n from collections import defaultdict\n-from pytorch_pretrained_bert import BertTokenizer, BertModel, BertForMaskedLM\n \n import bert_score\n \n-VERSION=bert_score.__version__\n \n def main():\n torch.multiprocessing.set_sharing_strategy('file_system')\n \n parser = argparse.ArgumentParser('Calculate BERTScore')\n- parser.add_argument('--bert', default='bert-base-multilingual-cased',\n- choices=bert_score.bert_types, help='BERT model name (default: bert-base-uncased)')\n- parser.add_argument('-l', '--num_layers', type=int, default=8, help='use first N layer in BERT (default: 8)')\n+ parser.add_argument('--lang', type=str, default=None, help='two-letter abbreviation of the language (e.g., en)')\n+ parser.add_argument('-m', '--model', default=None,\n+ choices=bert_score.model_types, help='BERT model name (default: bert-base-uncased)')\n+ parser.add_argument('-l', '--num_layers', type=int, default=None, help='use first N layer in BERT (default: 8)')\n parser.add_argument('-b', '--batch_size', type=int, default=64, help='batch size (default: 64)')\n- parser.add_argument('--no_idf', action='store_true', help='BERT Score without IDF scaling')\n+ parser.add_argument('--idf', action='store_true', help='BERT Score with IDF scaling')\n parser.add_argument('-s', '--seg_level', action='store_true', help='show individual score of each pair')\n parser.add_argument('-v', '--verbose', action='store_true', help='increase output verbosity')\n parser.add_argument('-r', '--ref', type=str, required=True, help='reference file path or a string')\n@@ -35,18 +34,19 @@ def main():\n else:\n cands = [args.cand]\n refs = [args.ref]\n- assert args.no_idf, \"do not suuport idf fold for a single pair of sentences\"\n+ assert not args.idf, \"do not suuport idf fold for a single pair of sentences\"\n \n assert len(cands) == len(refs)\n \n- all_preds = bert_score.score(cands, refs, bert=args.bert, num_layers=args.num_layers, verbose=args.verbose,\n- no_idf=args.no_idf, batch_size=args.batch_size)\n+ all_preds, hash_code = bert_score.score(cands, refs, model_type=args.model, num_layers=args.num_layers,\n+ verbose=args.verbose, idf=args.idf, batch_size=args.batch_size,\n+ lang=args.lang, return_hash=True)\n avg_scores = [s.mean(dim=0) for s in all_preds]\n P = avg_scores[0].cpu().item()\n R = avg_scores[1].cpu().item()\n F1 = avg_scores[2].cpu().item()\n- msg = '{}_L{}{}_version={} BERT-P: {:.6f} BERT-R: {:.6f} BERT-F1: {:.6f}'.format(\n- args.bert, args.num_layers, '_no-idf' if args.no_idf else '', VERSION, P, R, F1)\n+ msg = hash_code + \\\n+ f' BERT-P: {P:.6f} BERT-R: {R:.6f} BERT-F1: {F1:.6f}'\n print(msg)\n if args.seg_level:\n ps, rs, fs = all_preds\ndiff --git a/example/demo.py b/example/demo.py\n--- a/example/demo.py\n+++ b/example/demo.py\n@@ -6,4 +6,5 @@\n with open(\"refs.txt\") as f:\n refs = [line.strip() for line in f]\n \n-P, R, F = score(cands, refs, bert=\"bert-base-uncased\")\n+P, R, F = score(cands, refs, lang='en')\n+print(f'P={P:.6f} R={R:.6f} F={F:.6f}')\ndiff --git a/setup.py b/setup.py\n--- a/setup.py\n+++ b/setup.py\n@@ -3,7 +3,7 @@\n \n setup(\n name=\"bert_score\",\n- version=\"0.1.2\",\n+ version='0.2.0',\n author=\"Tianyi Zhang*, Varsha Kishore*, Felix Wu*, Kilian Q. Weinberger, and Yoav Artzi\",\n author_email=\"tzhang@asapp.com\",\n description=\"PyTorch implementation of BERT score\",\n@@ -14,12 +14,13 @@\n url=\"https://github.com/Tiiiger/bert_score\",\n packages=find_packages(exclude=[\"*.tests\", \"*.tests.*\",\n \"tests.*\", \"tests\"]),\n- install_requires=['torch>=0.4.1',\n+ install_requires=['torch>=1.0.0',\n 'numpy',\n 'requests',\n 'tqdm>=4.31.1',\n 'matplotlib',\n- 'pytorch-pretrained-bert>=0.6.1'],\n+ 'transformers>=2.0.0'\n+ ],\n entry_points={\n 'console_scripts': [\n \"bert-score=cli.score:main\",\n", "test_patch": "diff --git a/tests/__init__.py b/tests/__init__.py\nnew file mode 100644\ndiff --git a/tests/test_bert_score.py b/tests/test_bert_score.py\nnew file mode 100644\n--- /dev/null\n+++ b/tests/test_bert_score.py\n@@ -0,0 +1,46 @@\n+import unittest\n+import torch\n+import bert_score\n+\n+from collections import defaultdict\n+\n+eps = 1e-6\n+\n+cands = [\n+ \"28-year-old chef found dead in San Francisco mall\",\n+ \"A 28-year-old chef who recently moved to San Francisco was found dead in the staircase of a local shopping center.\",\n+ \"The victim's brother said he cannot imagine anyone who would want to harm him,\\\"Finally, it went uphill again at him.\\\"\",\n+]\n+refs = [\n+ \"28-Year-Old Chef Found Dead at San Francisco Mall\",\n+ \"A 28-year-old chef who had recently moved to San Francisco was found dead in the stairwell of a local mall this week.\",\n+ \"But the victim's brother says he can't think of anyone who would want to hurt him, saying, \\\"Things were finally going well for him.\\\"\"\n+]\n+\n+class TestScore(unittest.TestCase):\n+ def test_score(self):\n+ (P, R, F), hash_code = bert_score.score(cands, refs, model_type='roberta-large', num_layers=17,\n+ idf=False, batch_size=3, return_hash=True)\n+ print(P.tolist(), R.tolist(), F.tolist())\n+\n+ self.assertTrue(torch.is_tensor(P))\n+ self.assertTrue(torch.is_tensor(R))\n+ self.assertTrue(torch.is_tensor(F))\n+ self.assertEqual(hash_code, f'roberta-large_L17_no-idf_version={bert_score.__version__}')\n+ self.assertTrue((P - torch.tensor([0.9862896203994751, 0.9817618131637573, 0.9145744442939758])).abs_().max() < eps)\n+ self.assertTrue((R - torch.tensor([0.986611008644104, 0.9717907905578613, 0.9223880767822266])).abs_().max() < eps)\n+ def test_idf_score(self):\n+ (P, R, F), hash_code = bert_score.score(cands, refs, model_type='roberta-large', num_layers=17,\n+ idf=True, batch_size=3, return_hash=True)\n+ print(P.tolist(), R.tolist(), F.tolist())\n+\n+ self.assertTrue(torch.is_tensor(P))\n+ self.assertTrue(torch.is_tensor(R))\n+ self.assertTrue(torch.is_tensor(F))\n+ self.assertEqual(hash_code, f'roberta-large_L17_idf_version={bert_score.__version__}')\n+ self.assertTrue((P - torch.tensor([0.9841673374176025, 0.9752232432365417, 0.8989502787590027])).abs_().max() < eps)\n+ self.assertTrue((R - torch.tensor([0.9843330979347229, 0.9698787927627563, 0.9181708097457886])).abs_().max() < eps)\n+ self.assertTrue((F - torch.tensor([0.9842502474784851, 0.9725437164306641, 0.908458948135376])).abs_().max() < eps)\n+\n+if __name__ == '__main__':\n+ unittest.main()\n", "problem_statement": "", "hints_text": "", "created_at": "2019-10-02T20:45:52Z"} | |